import type { FunctionN, Lazy, Predicate, Refinement } from "../Function";
import type { Option } from "../Option";
import type { Either } from "./model";
/**
 * ```haskell
 * left :: e -> Left e
 * ```
 *
 * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this structure
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const left: <E = never, A = never>(e: E) => Either<E, A>;
/**
 * ```haskell
 * right :: a -> Right a
 * ```
 *
 * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias of this structure
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const right: <E = never, A = never>(a: A) => Either<E, A>;
/**
 *
 * ```haskell
 * fromNullable :: (() -> e) -> ?a -> Either e a
 * ```
 
 * Takes a default and a nullable value, if the value is not nully, turn it into a `Right`, if the value is nully use the provided default as a `Left`
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromNullable: <E>(e: Lazy<E>) => <A>(a: A) => Either<E, NonNullable<A>>;
/**
 * ```haskell
 * _partial :: (() -> a, (* -> e)) -> Either e a
 * ```
 *
 * Constructs a new `Either` from a function that might throw
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partial_: <E, A>(a: Lazy<A>, onThrow: (reason: unknown) => E) => Either<E, A>;
/**
 * ```haskell
 * partial :: (* -> e) -> (() -> a) -> Either e a
 * ```
 *
 * Constructs a new `Either` from a function that might throw
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partial: <E>(onError: (reason: unknown) => E) => <A>(a: Lazy<A>) => Either<E, A>;
/**
 * ```haskell
 * _partialK :: (((a, b, ...) -> c), (* -> e)) -> ((a, b, ...) -> Either e c)
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partialK_: <A extends readonly unknown[], B, E>(
   f: FunctionN<A, B>,
   onThrow: (reason: unknown) => E
) => (...args: A) => Either<E, B>;
/**
 * ```haskell
 * partialK :: (* -> e) -> ((a, b, ...) -> c) -> ((a, b, ...) -> Either e c)
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const partialK: <E>(
   onThrow: (reason: unknown) => E
) => <A extends readonly unknown[], B>(f: FunctionN<A, B>) => (...args: A) => Either<E, B>;
export declare type Json = boolean | number | string | null | JsonArray | JsonRecord;
export interface JsonRecord extends Readonly<Record<string, Json>> {}
export interface JsonArray extends ReadonlyArray<Json> {}
/**
 * ```haskell
 * _parseJSON :: (String, (* -> e)) -> Either e Json
 * ```
 *
 * Converts a JavaScript Object Notation (JSON) string into an object.
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const parseJson_: <E>(s: string, onThrow: (reason: unknown) => E) => Either<E, Json>;
/**
 * ```haskell
 * parseJSON :: (* -> e) -> String -> Either e Json
 * ```
 *
 * Converts a JavaScript Object Notation (JSON) string into an object.
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const parseJson: <E>(onThrow: (reason: unknown) => E) => (s: string) => Either<E, Json>;
/**
 * ```haskell
 * _stringifyJSON :: (*, (* -> E)) -> Either e String
 * ```
 *
 * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const stringifyJson_: <E>(u: unknown, onThrow: (reason: unknown) => E) => Either<E, string>;
/**
 * ```haskell
 * stringifyJSON :: (* -> E) -> * -> Either e String
 * ```
 *
 * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const stringifyJSON: <E>(onThrow: (reason: unknown) => E) => (u: unknown) => Either<E, string>;
/**
 * ```haskell
 * _fromMaybe :: (Maybe a, (() -> e)) -> Either e a
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromOption_: <E, A>(fa: Option<A>, onNothing: Lazy<E>) => Either<E, A>;
/**
 * ```haskell
 * fromMaybe :: (() -> e) -> Maybe a -> Either e a
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromOption: <E>(onNothing: Lazy<E>) => <A>(fa: Option<A>) => Either<E, A>;
/**
 * ```haskell
 * _fromPredicate :: (a, (a is b), (a -> e)) -> Either e b
 * _fromPredicate :: (a, (a -> Boolean), (a -> e)) -> Either e a
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromPredicate_: {
   <E, A, B extends A>(a: A, refinement: Refinement<A, B>, onFalse: (a: A) => E): Either<E, B>;
   <E, A>(a: A, predicate: Predicate<A>, onFalse: (a: A) => E): Either<E, A>;
};
/**
 * ```haskell
 * fromPredicate :: ((a is b), (a -> e)) -> a -> Either e b
 * fromPredicate :: ((a -> Boolean), (a -> e)) -> a -> Either e a
 * ```
 *
 * @category Constructors
 * @since 1.0.0
 */
export declare const fromPredicate: {
   <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (a: A) => Either<E, B>;
   <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => Either<E, A>;
};
//# sourceMappingURL=constructors.d.ts.map