/**
 *    |-----------------------|-------------------|
 *    | Rust methods          | Perlica           |
 *    |-----------------------|-------------------|
 *    | and                   | and               |
 *    | and_then              | andThen           |
 *    | as_deref              |                   |
 *    | as_deref_mut          |                   |
 *    | as_mut                |                   |
 *    | as_mut_slice          |                   |
 *    | as_pin_mut            |                   |
 *    | as_pin_ref            |                   |
 *    | as_ref                |                   |
 *    | as_slice              |                   |
 *    | cloned                |                   |
 *    | copied                |                   |
 *    | expect                | expect            |
 *    | filter                | filter            |
 *    | flatten               | flatten           |
 *    | get_or_insert         |                   |
 *    | get_or_insert_default |                   |
 *    | get_or_insert_with    |                   |
 *    | insert                |                   |
 *    | inspect               | inspect           |
 *    | is_none               | isNone            |
 *    | is_none_or            | isNoneOr          |
 *    | is_some               | isSome            |
 *    | is_some_and           | isSomeAnd         |
 *    | iter                  |                   |
 *    | iter_mut              |                   |
 *    | map                   | map               |
 *    | map_or                | mapOr             |
 *    | map_or_else           | mapOrElse         |
 *    | ok_or                 | okOr              |
 *    | ok_or_else            | okOrElse          |
 *    | or                    | or                |
 *    | or_else               | orElse            |
 *    | replace               |                   |
 *    | take                  |                   |
 *    | take_if               |                   |
 *    | transpose             | transpose         |
 *    | unwrap                | unwrap            |
 *    | unwrap_or             | unwrapOr          |
 *    | unwrap_or_default     |                   |
 *    | unwrap_or_else        | unwrapOrElse      |
 *    | unwrap_unchecked      |                   |
 *    | unzip                 |                   |
 *    | xor                   | xor               |
 *    | zip                   |                   |
 *    | zip_with              |                   |
 *    |-----------------------|-------------------|
 */
import { OnceIterator } from "./Iterator";
import { type Result } from "./Result";
export type SomeType<R> = R extends Option<infer T> ? T : any;
export interface OptionTrait<T> {
    and<U, T>(this: Option<T>, v: Option<U>): Option<U>;
    andThen<U, T>(this: Option<T>, f: (v: T) => Option<U>): Option<U>;
    expect<T>(this: Option<T>, msg: string): T;
    filter<T>(this: Option<T>, f: (v: T) => boolean): Option<T>;
    flatten<T>(this: Option<Option<T>>): Option<T>;
    inspect<T>(this: Option<T>, f: (v: T) => void): Option<T>;
    isNone<T>(this: Option<T>): boolean;
    isNoneOr<T>(this: Option<T>, f: (v: T) => boolean): boolean;
    isSome<T>(this: Option<T>): boolean;
    isSomeAnd<T>(this: Option<T>, f: (v: T) => boolean): boolean;
    map<U, T>(this: Option<T>, f: (v: T) => U): Option<U>;
    mapOr<U, T>(this: Option<T>, def: U, f: (v: T) => U): U;
    mapOrElse<U, T>(this: Option<T>, d: () => U, f: (v: T) => U): U;
    okOr<T, E>(this: Option<T>, v: E): Result<T, E>;
    okOrElse<T, E>(this: Option<T>, f: () => E): Result<T, E>;
    or<T>(this: Option<T>, v: Option<T>): Option<T>;
    orElse<T>(this: Option<T>, f: () => Option<T>): Option<T>;
    transpose<T, E>(this: Option<Result<T, E>>): Result<Option<T>, E>;
    unwrap: <T>(this: Option<T>) => T;
    unwrapOr<T>(this: Option<T>, def: T): T;
    unwrapOrElse<T>(this: Option<T>, def: () => T): T;
    xor<T>(this: Option<T>, v: Option<T>): Option<T>;
    [Symbol.iterator](this: Option<T>): OnceIterator<Option<T>, T>;
}
export declare const isSome: <T>(r: Option<T>) => r is Some<T>;
export declare const isNone: <T>(r: Option<T>) => r is None;
export interface Some<T> extends OptionTrait<T> {
    value: T;
    tag: "some";
}
export interface None extends OptionTrait<never> {
    tag: "none";
}
export type Option<T> = Some<T> | None;
export declare const OptionProto: <T>() => OptionTrait<T>;
export declare const fromNullable: <T>(v: T) => Option<NonNullable<T>>;
export declare const fromResult: <T, E>(v: Result<T, E>) => Option<T>;
export declare const tryCatch: <T>(f: () => T) => Option<T>;
export declare const tryPromise: <T>(v: Promise<T>) => Promise<Option<T>>;
export declare const some: <T = never>(v: T) => Option<T>;
export declare const none: <T = never>() => Option<T>;
interface Bind {
    <T extends Option<any>, R>(fn: () => Generator<T, R>): Option<R>;
}
export declare const bind: Bind;
export {};