import type { Either } from "../Either";
import type { FunctionN, Lazy, Predicate, Refinement } from "../Function";
import type { Option } from "./model";
/**
 * ```haskell
 * nothing :: <a> () -> Nothing
 * ```
 *
 * Constructs a new `Maybe` holding no value (a.k.a `Nothing`)
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const none: <A = never>() => Option<A>;
/**
 * ```haskell
 * just :: a -> Just a
 * ```
 *
 * Constructs a new `Maybe` holding a `Just` value.
 *
 * @category Constructs
 * @since 1.0.0
 */
export declare const some: <A>(a: A) => Option<A>;
/**
 * ```haskell
 * fromNullable :: ?a -> Maybe a
 * ```
 *
 * Constructs a new `Maybe` from a nullable value. If the value is `null` or `undefined`, returns `Nothing`, otherwise
 * returns the value wrapped in a `Just`
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromNullable: <A>(a: A | null | undefined) => Option<NonNullable<A>>;
/**
 * ```haskell
 * partial :: (() -> a) -> Maybe a
 * ```
 *
 * Constructs a new `Maybe` from a function that might throw
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partial: <A>(thunk: Lazy<A>) => Option<A>;
/**
 * ```haskell
 * partialK :: ((a, b, ...) -> c) -> ((a, b, ...) -> Maybe c)
 * ```
 *
 * Transforms a non-curried function that may throw, takes a set of arguments `(a, b, ...)`, and returns a value `c`, into a non-curried function that will not throw, takes a set of arguments `(a, b, ...)`, and returns a `Maybe`
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partialK: <A extends readonly unknown[], B>(f: FunctionN<A, B>) => (...args: A) => Option<B>;
/**
 * ```haskell
 * fromPredicate_ :: (a, (a -> is b)) -> Maybe b
 * fromPredicate_ :: (a, (a -> Boolean)) -> Maybe a
 * ```
 *
 * Constructs a new `Maybe` from a value and the given predicate
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromPredicate_: {
   <A, B extends A>(a: A, refinement: Refinement<A, B>): Option<A>;
   <A>(a: A, predicate: Predicate<A>): Option<A>;
};
/**
 * ```haskell
 * fromPredicate :: (a -> is b) -> a -> Maybe b
 * fromPredicate :: (a -> Boolean) -> a -> Maybe a
 * ```
 *
 * Returns a smart constructor based on the given predicate
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromPredicate: {
   <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Option<A>;
   <A>(predicate: Predicate<A>): (a: A) => Option<A>;
};
/**
 * ```haskell
 * fromEither :: Either e a -> Maybe a
 * ```
 *
 * Constructs a new `Maybe` from an `Either`, transforming a `Left` into a `Nothing` and a `Right` into a `Just`.
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromEither: <E, A>(ma: Either<E, A>) => Option<A>;
//# sourceMappingURL=constructors.d.ts.map