/**
 *    |----------------------|------------------|
 *    | Rust methods         | Perlica          |
 *    |----------------------|------------------|
 *    | and                  | and              |
 *    | and_then             | andThen          |
 *    | as_deref             |                  |
 *    | as_deref_mut         |                  |
 *    | as_mut               |                  |
 *    | as_ref               |                  |
 *    | cloned               |                  |
 *    | copied               |                  |
 *    | err                  | err              |
 *    | expect               | expect           |
 *    | expect_err           | expectErr        |
 *    | flatten              | flatten          |
 *    | inspect              | inspect          |
 *    | inspect_err          | inspectErr       |
 *    | into_err             |                  |
 *    | into_ok              |                  |
 *    | is_err               | isErr            |
 *    | is_err_and           | isErrAnd         |
 *    | is_ok                | isOk             |
 *    | is_ok_and            | isOkAnd          |
 *    | iter                 |                  |
 *    | iter_mut             |                  |
 *    | map                  | map              |
 *    | map_err              | mapErr           |
 *    | map_or               | mapOr            |
 *    | map_or_else          | mapOrElse        |
 *    | ok                   | ok               |
 *    | or                   | or               |
 *    | or_else              | orElse           |
 *    | transpose            | transpose        |
 *    | unwrap               | unwrap           |
 *    | unwrap_err           | unwrapErr        |
 *    | unwrap_err_unchecked |                  |
 *    | unwrap_or            | unwrapOr         |
 *    | unwrap_or_default    |                  |
 *    | unwrap_or_else       | unwrapOrElse     |
 *    | unwrap_unchecked     |                  |
 *    |----------------------|------------------|
 */
import { OnceIterator } from "./Iterator";
import { type Option } from "./Option";
export type OkType<R> = R extends Result<infer T, any> ? T : any;
export type ErrType<R> = R extends Result<any, infer E> ? E : any;
export interface ResultTrait<T, E> {
    and<U, T, E>(this: Result<T, E>, f: (v: T) => U): Result<U, E>;
    andThen<U, T, E>(this: Result<T, E>, f: (v: T) => Result<U, E>): Result<U, E>;
    err<T, E>(this: Result<T, E>): Option<E>;
    expect<T, E>(this: Result<T, E>, msg: string): T;
    expectErr<T, E>(this: Result<T, E>, msg: string): E;
    flatten<T, E>(this: Result<Result<T, E>, E>): Result<T, E>;
    inspect: <T, E>(this: Result<T, E>, f: (v: T) => void) => Result<T, E>;
    inspectErr<T, E>(this: Result<T, E>, f: (v: E) => void): Result<T, E>;
    isErr<T, E>(this: Result<T, E>): boolean;
    isErrAnd<T, E>(this: Result<T, E>, f: (v: E) => boolean): boolean;
    isOk<T, E>(this: Result<T, E>): boolean;
    isOkAnd<T, E>(this: Result<T, E>, f: (v: T) => boolean): boolean;
    map<U, T, E>(this: Result<T, E>, f: (v: T) => U): Result<U, E>;
    mapErr<U, T, E>(this: Result<T, E>, f: (v: E) => U): Result<T, U>;
    mapOr<U, T, E>(this: Result<T, E>, def: U, f: (v: T) => U): U;
    mapOrElse<U, T, E>(this: Result<T, E>, def: (v: E) => U, f: (v: T) => U): U;
    ok<T, E>(this: Result<T, E>): Option<T>;
    or<U, T, E>(this: Result<T, E>, f: (v: E) => U): Result<T, U>;
    orElse<U, T, E>(this: Result<T, E>, f: (v: E) => Result<T, U>): Result<T, U>;
    transpose<T, E>(this: Result<Option<T>, E>): Option<Result<T, E>>;
    unwrap<T, E>(this: Result<T, E>): T;
    unwrapErr<T, E>(this: Result<T, E>): E;
    unwrapOr<T, E>(this: Result<T, E>, def: T): T;
    unwrapOrElse<T, E>(this: Result<T, E>, def: (v: E) => T): T;
    [Symbol.iterator](this: Result<T, E>): OnceIterator<Result<T, E>, T>;
}
export declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
export declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
export interface Ok<T> extends ResultTrait<T, never> {
    tag: "ok";
    value: T;
}
export interface Err<E> extends ResultTrait<never, E> {
    tag: "err";
    value: E;
}
export type Result<T, E> = Ok<T> | Err<E>;
export declare const ResultProto: <T, E>() => ResultTrait<T, E>;
export declare const fromNullable: <T, E>(v: T, f: () => E) => Result<T, E>;
export declare const fromOption: <T, E>(v: Option<T>, f: () => E) => Result<T, E>;
export declare const tryCatch: <T, E>(f: () => T) => Result<T, E>;
export declare const tryPromise: <T, E>(v: Promise<T>) => Promise<Result<T, E>>;
export declare const ok: <T, E = never>(v: T) => Result<T, E>;
export declare const err: <E, T = never>(v: E) => Result<T, E>;
interface Bind {
    <T extends Result<any, any>, R>(fn: () => Generator<T, R>): Result<R, T extends Err<infer E> ? E : never>;
}
export declare const bind: Bind;
export {};