import { Box } from "./box";
import { DefaultOrFunc } from "./fn";
import { Result } from "./result";
/** Means no value */
export declare type None = null | undefined;
/** May have no value
 * ```ts
 * type Maybe<T> = T | None
 * ```
*/
export declare type Maybe<T> = T | None;
/** T or null */
export declare type Nullable<T> = T | null;
/** T or undefined */
export declare type Voidable<T> = T | undefined;
/** Check is value */
export declare function isSome<T>(v: Maybe<T>): v is T;
/** Check is no value */
export declare function isNone<T>(v: Maybe<T>): v is None;
export declare namespace Maybe {
    /** Map if there is a value, otherwise return undefined
     *
     * ## Example
     * ```ts
     * let a: 2 = map(1, v => v + 1)
     * let b: undefined = map(null, v => v + 1)
     * ```
    */
    function map<T, U>(v: Maybe<T>, f: (v: T) => U): Voidable<U>;
    /** Map if there is a value, otherwise return default value
     *
     * ## Example
     * ```ts
     * let a: 2 = map(1, 3, v => v + 1)
     * let b: 3 = map(null, 3, v => v + 1)
     * ```
    */
    function mapOr<T, U>(v: Maybe<T>, defv: DefaultOrFunc<U>, f: (v: T) => U): U;
    /** If there is a value, pack it as ok, otherwise pack err * ```
    */
    function okOr<T, E>(v: Maybe<T>, e: DefaultOrFunc<E>): Result<T, E>;
    /** Return undefined if the value is None, otherwise return other. */
    function and<T, U>(v: Maybe<T>, other: Maybe<U>): Maybe<U>;
    /** Return undefined if the value is None, otherwise call f with the value and return the result */
    function then<T, U>(v: Maybe<T>, f: (v: T) => Maybe<U>): Maybe<U>;
    /** Return the value if the value is value, otherwise return other */
    function or<T>(v: Maybe<T>, other: Maybe<T>): Maybe<T>;
    /** return value if exactly one of `v`, `other`  is value, otherwise return undefined */
    function xor<T>(v: Maybe<T>, other: Maybe<T>): Voidable<T>;
    /** Transpose to result */
    function transpose<T, E>(v?: Maybe<Result<T, E>>): Result<Voidable<T>, E>;
    /** Take the value, set the value in the box to undefined */
    function take<T>(v: Box<Maybe<T>>): Voidable<T>;
    /** Replace the value in the box */
    function replace<T>(v: Box<Maybe<T>>, val: T): Maybe<T>;
    /** As long as any value in the tuple is None, return undefined
     *
     * ## Example
     * ```ts
     * let a: [1, 2, 3] = zip(1, 2, 3)
     * let b: undefined = zip(1, null, 3)
     * let c: undefined = zip(1, 2, undefined)
     * ```
    */
    function zip<O extends Maybe<unknown>[]>(...o: O): Voidable<{
        [I in keyof O]: O[I] extends Maybe<infer V> ? V : never;
    }>;
}