import { MaybeAsync } from './maybeAsync.js';
import { Result } from './result.js';
import { Unit } from './unit.js';
import { Action, ActionOfT, AsyncAction, AsyncActionOfT, FunctionOfT, FunctionOfTtoK, MaybeMatcher, MaybeMatcherNoReturn, None, PredicateOfT, Some } from './utilities.js';
/**
 * Represents a value that might not exist. Undefined and null values are always represented as Maybe.none.
 */
export declare class Maybe<TValue> {
    /**
     * Creates a new Maybe with a value
     * @param value The value of the new maybe
     * @returns
     */
    static some<TValue>(value: Some<TValue>): Maybe<TValue>;
    /**
     * Creates a new Maybe with no value
     * @returns {Maybe}
     */
    static none<TValue>(): Maybe<TValue>;
    /**
     * Creates a new Maybe. If no value is provided, it is equivalent to calling Maybe.none(), and
     * if a value is provided, it is equivalent to calling Maybe.some(val)
     * @param value The value of the new Maybe.
     * @returns {Maybe}
     */
    static from<TValue>(value: Some<TValue> | None): Maybe<TValue>;
    /**
     * Returns a Maybe containing the first value of the array,
     * and a Maybe.none if the array is empty
     * @param values
     */
    static tryFirst<TValue>(values: TValue[]): Maybe<TValue>;
    /**
     * Returns a Maybe containing the value of the first element
     * of the array matching the condition of the predicate, and
     * a Maybe.none if there are no matches
     * @param values
     * @param predicate
     */
    static tryFirst<TValue>(values: Some<TValue>[], predicate: PredicateOfT<Some<TValue>>): Maybe<TValue>;
    /**
     * Returns a Maybe containing the last value of the array,
     * and a Maybe.none if the array is empty
     * @param values
     */
    static tryLast<TValue>(values: TValue[]): Maybe<TValue>;
    /**
     * Returns a Maybe containing the value of the last element
     * of the array matching the condition of the predicate, and
     * a Maybe.none if there are no matches
     * @param values
     * @param predicate
     */
    static tryLast<TValue>(values: Some<TValue>[], predicate: PredicateOfT<Some<TValue>>): Maybe<TValue>;
    /**
     * Returns only the Maybe instances of the array that have
     * values
     * @param maybes
     */
    static choose<TValue>(maybes: Maybe<TValue>[]): TValue[];
    /**
     * Returns only the Maybe instances of the array that have values,
     * passing each value to the given projection to be transformed to a new
     * value
     * @param maybes
     * @param projection
     */
    static choose<TValue, TNewValue>(maybes: Maybe<TValue>[], projection: FunctionOfTtoK<TValue, Some<TNewValue>>): TNewValue[];
    private value;
    /**
     * Returns true if the Maybe contains a value
     */
    get hasValue(): boolean;
    /**
     * Returns true if the Maybe has no value
     */
    get hasNoValue(): boolean;
    protected constructor(value: Some<TValue> | None);
    /**
     * Returns the value of the Maybe if it has one,
     * and the default value if there is none
     * @param defaultValue
     */
    getValueOrDefault(defaultValue: Some<TValue>): TValue;
    /**
     * Returns the value of the Maybe if it has one,
     * and returns the result of the factory function if
     * there is none
     * @param factory
     */
    getValueOrDefault(factory: FunctionOfT<Some<TValue>>): TValue;
    /**
     * Returns the value of the Maybe and throws
     * and Error if there is none
     * @returns
     */
    getValueOrThrow(): Some<TValue>;
    pipe(): Maybe<TValue>;
    pipe<A>(op1: MaybeOpFnAsync<TValue, A>): MaybeAsync<A>;
    pipe<A>(op1: MaybeOpFn<TValue, A>): Maybe<A>;
    pipe<A, B>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFnAsync<A, B>): MaybeAsync<B>;
    pipe<A, B>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>): Maybe<B>;
    pipe<A, B, C>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>): Maybe<C>;
    pipe<A, B, C>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFnAsync<B, C>): Maybe<C>;
    pipe<A, B, C, D>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>): Maybe<D>;
    pipe<A, B, C, D>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFnAsync<C, D>): Maybe<D>;
    pipe<A, B, C, D, E>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>): Maybe<E>;
    pipe<A, B, C, D, E>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFnAsync<D, E>): Maybe<E>;
    pipe<A, B, C, D, E, F>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFn<E, F>): Maybe<F>;
    pipe<A, B, C, D, E, F>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFnAsync<E, F>): Maybe<F>;
    pipe<A, B, C, D, E, F, G>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFn<E, F>, op7: MaybeOpFn<F, G>): Maybe<G>;
    pipe<A, B, C, D, E, F, G>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFn<E, F>, op7: MaybeOpFnAsync<F, G>): Maybe<G>;
    pipe<A, B, C, D, E, F, G, H>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFn<E, F>, op7: MaybeOpFn<F, G>, op8: MaybeOpFn<G, H>): Maybe<H>;
    pipe<A, B, C, D, E, F, G, H>(op1: MaybeOpFn<TValue, A>, op2: MaybeOpFn<A, B>, op3: MaybeOpFn<B, C>, op4: MaybeOpFn<C, D>, op5: MaybeOpFn<D, E>, op6: MaybeOpFn<E, F>, op7: MaybeOpFn<F, G>, op8: MaybeOpFnAsync<G, H>): Maybe<H>;
    /**
     * Converts the value of the Maybe, if there is one, to a new value
     * as defined by the provided projection function
     * @param projection
     * @returns
     */
    map<TNewValue>(projection: FunctionOfTtoK<TValue, Some<TNewValue>>): Maybe<TNewValue>;
    /**
     * Converts the value of the Maybe, if there is one, to a new value
     * as defined by the provided projection, wrapping the asynchronous result in a MaybeAsync
     * @param projection
     * @returns
     */
    mapAsync<TNewValue>(projection: FunctionOfTtoK<TValue, Promise<Some<TNewValue>>>): MaybeAsync<TNewValue>;
    /**
     * Executes the given action if the Maybe has a value
     * @param action
     * @returns
     */
    tap(action: ActionOfT<TValue>): Maybe<TValue>;
    /**
     * Executes the given asynchronous action if the Maybe has a
     * value and retursn a new MaybeAsync
     * @param asyncAction
     * @returns
     */
    tapAsync(asyncAction: FunctionOfTtoK<TValue, Promise<void>>): MaybeAsync<TValue>;
    /**
     * Executes an action if the Maybe has no value
     * @param action
     */
    tapNone(action: Action): Maybe<TValue>;
    /**
     * Executes an action if the Maybe has no value
     * @param action
     */
    tapNoneAsync(action: AsyncAction): MaybeAsync<TValue>;
    /**
     * Converts the value of the Maybe, if it has one, to a new Maybe
     * @param projection
     * @returns
     */
    bind<TNewValue>(projection: FunctionOfTtoK<TValue, Maybe<Some<TNewValue>>>): Maybe<TNewValue>;
    /**
     * Converts the value of the Maybe, if it has one, to a new
     * MaybeAsync
     * @param projection
     * @returns
     */
    bindAsync<TNewValue>(projection: FunctionOfTtoK<TValue, MaybeAsync<Some<TNewValue>>>): MaybeAsync<TNewValue>;
    /**
     * Maps the value of the Maybe, if it has one, using the given projection some function,
     * and the none function otherwise
     * @param projection
     */
    match<TNewValue>(projection: MaybeMatcher<TValue, TNewValue>): TNewValue;
    /**
     * Executes the some function of the given matcher if the Maybe has a value,
     * and the none function if there is no value
     * @param matcher
     * @returns
     */
    match(matcher: MaybeMatcherNoReturn<TValue>): Unit;
    /**
     * Executes the given action if the Maybe has a value
     * @param action
     */
    execute(action: ActionOfT<TValue>): Unit;
    /**
     * Executes the given async action if the Maybe has a value
     * @param action A void Promise returning function
     * @returns A Promise containing Unit
     */
    executeAsync(action: AsyncActionOfT<TValue>): Promise<Unit>;
    /**
     * Returns the Maybe if it has a value, otherwise it returns
     * the fallbackValue returned in a Maybe
     * @param fallbackValue
     */
    or(fallbackValue: Some<TValue>): Maybe<TValue>;
    /**
     * Returns the Maybe if it has a value, otherwise it returns the fallbackMaybe
     * @param fallbackMaybe
     */
    or(fallbackMaybe: Maybe<TValue>): Maybe<TValue>;
    /**
     * Returns the Maybe if it has a value, otherwise executes and
     * returns the value of the fallbackFactory wrapped in a Maybe
     * @param fallbackfactory
     */
    or(fallbackfactory: FunctionOfT<Some<TValue>>): Maybe<TValue>;
    /**
     * Returns the Maybe if it has a value, otherwise executes the fallbackMaybeFactory
     * and returns its result
     * @param fallbackMaybefactory
     */
    or(fallbackMaybefactory: FunctionOfT<Maybe<TValue>>): Maybe<TValue>;
    /**
     * Returns the Maybe, wrapped in a MaybeAsync, if it has a value, otherwise
     * returns the fallback MaybeAsync
     * @param fallbackPromise
     * @returns
     */
    orAsync(fallbackMaybeAsync: MaybeAsync<TValue>): MaybeAsync<TValue>;
    /**
     * Returns the Maybe, wrapped in a MaybeAsync, if it has a value, otherwise
     * returns executes the fallbackPromiseFactory and returns its value wrapped in a MaybeAsync
     * @param fallbackPromise
     * @returns
     */
    orAsync(fallbackPromiseFactory: FunctionOfT<Promise<Some<TValue>>>): MaybeAsync<TValue>;
    /**
     * Returns the Maybe, wrapped in a MaybeAsync, if it has a value, otherwise
     * returns the fallbackPromise, wrapped in a MaybeAsync
     * @param fallbackPromise
     */
    orAsync(fallbackPromise: Promise<Some<TValue>>): MaybeAsync<TValue>;
    /**
     * Converts the Maybe into a Result. The Result is successful if there is a value
     * and a failure, with the given error, if there is not
     * @param error
     * @returns
     */
    toResult<TError>(error: Some<TError>): Result<TValue, TError>;
    /**
     * Returns the string representation of the Maybe (either some or none)
     * @returns
     */
    toString(): string;
    /**
     * Returns true if the Maybes both have values and the values are strictly equal
     * @param maybe
     * @returns
     */
    equals(maybe: Maybe<TValue>): boolean;
}
export type MaybeOpFn<A, B> = FunctionOfTtoK<Maybe<A>, Maybe<B>>;
export type MaybeOpFnAsync<A, B> = FunctionOfTtoK<Maybe<A>, MaybeAsync<B>>;