import { MapOption, Option, OptionFrom, OptionLike, OptionMapOption, OptionMapOrElse, OptionMapResult, OptionPromise, OptionPromiseMapOption, OptionPromiseMapOrElse, OptionPromiseMapResult, Result, ResultPromise, UnwrapableOption } from "./mod";
/**
 * Create an {@linkcode OptionPromise} from a value.
 * @example
 * ```typescript
 * declare function calculate(n: number): OptionPromise<number>;
 * Some(42)
 *   .mapOption(
 *     // when using Some here, the compiler will error on calculate with an Argument Error
 *     () => SomePromise(-1),
 *     calculate
 *   );
 * ```
 */
export declare function SomePromise<T>(value: T): OptionPromise<T>;
/**
 * `None` creates an Option that has no associated value. It might be useful to
 * pass a type argument:
 * ```typescript
 * const token = None<string>();
 * token.insert(12); // will give a compile error that the argument must be string
 * ```
 */
export declare function None<T>(): Option<T>;
/**
 * Create an {@linkcode OptionPromise} without a value.
 * @example
 * ```typescript
 * declare function calculate(n: number): OptionPromise<number>;
 * Some(42)
 *   .mapOption(
 *     // when using Some here, the compiler will error on calculate with an Argument Error
 *     () => NonePromise,
 *     calculate
 *   );
 * ```
 */
export declare function NonePromise<T>(): OptionPromise<T>;
/**
 * `Some` creates an Option which has an associated value. The type argument can be
 * inferred from the argument. Actually, `Some` is a bit special, as it also might
 * return a `None` value:
 * ```typescript
 * // All the statements below return a None
 * Some();
 * Some(null);
 * Some(Infinity);
 * Some(NaN);
 * ```
 * Passing a promise to `Some` results in an {@linkcode OptionPromise<T>}, which can be
 * convenient. When a `OptionPromise` is required e.g., for {@linkcode mapOrElse},
 * {@linkcode NonePromise} or {@linkcode SomePromise}
 */
export declare function Some<T>(value?: T | undefined | null): OptionFrom<T>;
/**
 * Test that a variable implements the {@linkcode Option<T>} interface
 * @returns true if variable can be cast to `Option<T>`
 *
 * @example
 * ```typescript
 * const vut: unknown = Some(42);
 * if (isOption(vut)) {
 *   console.log(vut.unwrapOr(-99));
 * }
 * ```
 */
export declare function isOption<T = unknown>(possibleOption: unknown): possibleOption is Option<T>;
/**
 * Test that a variable implements the {@linkcode OptionPromise<T>} interface
 * @returns true if variable can be cast to `OptionPromise<T>`
 *
 * @example
 * const vut: unknown = Some(Promise.resolve(42));
 * if (isOptionPromise<number>(vut)) {
 *   vut.map(console.log);
 * }
 */
export declare function isOptionPromise<T = unknown>(possibleOption: unknown): possibleOption is OptionPromise<T>;
export declare function isOptionLike<T = unknown>(possibleOption: unknown): possibleOption is OptionLike<T>;
export declare class OptionValue<T> implements Option<T>, UnwrapableOption<T> {
    private option;
    constructor(option: UnwrapableOption<T>);
    get type(): symbol;
    static from<T>(option: UnwrapableOption<T>): Option<T>;
    and<U>(optb: Option<U>): Option<U>;
    andThen<U>(fn: (some: T) => Promise<Option<U>>): OptionPromise<U>;
    andThen<U>(fn: (some: T) => Option<U>): Option<U>;
    filter(predicate: (some: T) => boolean): Option<T>;
    flatten<U>(this: Option<U>): Option<U>;
    flatten<U>(this: Option<Option<U>>): Option<U>;
    getOrInsert(value: T): T;
    getOrInsertWith(fn: () => T): T;
    insert(value: T): T;
    isSome(): boolean;
    isNone(): boolean;
    map<U>(fn: (some: T) => U): MapOption<U>;
    mapOption<U>(def: () => U, fn: (some: T) => U): OptionMapOption<U>;
    mapResult<U>(def: () => U, fn: (some: T) => U): OptionMapResult<U>;
    mapOrElse<U>(def: () => U, fn: (some: T) => U): OptionMapOrElse<U>;
    okOr<E>(err: E): Result<T, E>;
    okOrElse<E>(fn: () => Promise<E>): ResultPromise<T, E>;
    okOrElse<E>(fn: () => E): Result<T, E>;
    or(optb: Option<T>): Option<T>;
    orElse(fn: () => Promise<Option<T>>): OptionPromise<T>;
    orElse(fn: () => Option<T>): Option<T>;
    replace(value: T): Option<T>;
    take(): Option<T>;
    unwrap(): T;
    unwrapOr(def: T): T;
    unwrapOrElse(def: () => T): T;
    unwrapOrElse(def: () => Promise<T>): T | Promise<T>;
    xor(optb: Option<T>): Option<T>;
    [Symbol.iterator](): IterableIterator<T>;
}
export declare class PromisedOption<T> implements OptionPromise<T> {
    promise: Promise<Option<T>>;
    constructor(promise: Promise<Option<T>>);
    get [Symbol.toStringTag](): string;
    static from<U>(promise: Promise<Option<U>>): OptionPromise<U>;
    then<TResult1 = Option<T>, TResult2 = never>(onfulfilled?: ((value: Option<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): Promise<Option<T> | TResult>;
    finally(onfinally?: (() => void) | null | undefined): Promise<Option<T>>;
    and<U>(optb: Option<U>): OptionPromise<U>;
    andThen<U>(fn: (some: T) => OptionPromise<U>): OptionPromise<U>;
    andThen<U>(fn: (some: T) => Promise<Option<U>>): OptionPromise<U>;
    andThen<U>(fn: (some: T) => Option<U>): OptionPromise<U>;
    filter(predicate: (some: T) => boolean): OptionPromise<T>;
    flatten<U>(this: Option<Option<U>>): OptionPromise<U>;
    flatten<U>(this: Option<U>): OptionPromise<U>;
    isSome(): Promise<boolean>;
    isNone(): Promise<boolean>;
    map<U>(fn: (some: T) => U): OptionPromise<U>;
    mapOption<U>(def: () => U, fn: (some: T) => U): OptionPromiseMapOption<U>;
    mapResult<U>(def: () => U, fn: (some: T) => U): OptionPromiseMapResult<U>;
    mapOrElse<U>(def: () => U, fn: (some: T) => U): OptionPromiseMapOrElse<U>;
    okOr<E>(err: E): ResultPromise<T, E>;
    okOrElse<E>(fn: () => Promise<E>): ResultPromise<T, E>;
    or(optb: Option<T>): OptionPromise<T>;
    orElse(fn: () => Promise<Option<T>>): OptionPromise<T>;
    orElse(fn: () => Option<T>): OptionPromise<T>;
    unwrapOr(def: T): Promise<T>;
    unwrapOrElse(def: () => T): Promise<T>;
    unwrapOrElse(def: () => Promise<T>): Promise<T>;
    xor(optb: Option<T>): OptionPromise<T>;
}