export interface OptionMatch<T, U> {
    Some: ((val: T) => U) | U;
    None: (() => U) | U;
}
export interface ResultMatch<T, E, U> {
    Ok: ((val: T) => U) | U;
    Err: ((err: E) => U) | U;
}
interface IteratorResult<T> {
    done: boolean;
    value: RustOption<T>;
}
interface Iterator<T> {
    next(): IteratorResult<T>;
    [Symbol.iterator](): Iterator<T>;
}
declare class RustOptionBase<T> {
    protected value: T | undefined;
    constructor(val: T | undefined);
    valueOf(): T | undefined;
}
export declare class RustOption<T> extends RustOptionBase<T> {
    static Some(val: any): RustOption<typeof val>;
    static get None(): RustOption<any>;
    private constructor();
    isSome(): boolean;
    isNone(): boolean;
    unwrap(): T;
    unwrapOr(def: T): T;
    unwrapOrElse(fn: () => T): T;
    map<U>(fn: (val: T) => U): RustOption<U>;
    mapOr<U>(def: U, fn: (val: T) => U): U;
    mapOrElse<U>(fnNone: () => U, fnSome: (val: T) => U): U;
    match<U>(fn: OptionMatch<T, U>): U;
    contains(val: T): boolean;
    expect(msg: string): T;
    iter(): Iterator<T>;
    okOr<E>(err: E): RustResult<T, E>;
    okOrElse<E>(err: () => E): RustResult<T, E>;
    and<U>(v: RustOption<U>): RustOption<U>;
    andThen<U>(fn: (val: T) => RustOption<U>): RustOption<U>;
    or(v: RustOption<T>): RustOption<T>;
    orElse(fn: () => RustOption<T>): RustOption<T>;
    xor(v: RustOption<T>): RustOption<T>;
    filter(fn: (val: T) => boolean): RustOption<T>;
    getOrInsert(val: T): T;
    getOrInsertWith(fn: () => T): T;
    take(): RustOption<T>;
    replace(val: T): RustOption<T>;
    cloned(): RustOption<T>;
    expectNone(msg: string): void;
    unwrapNone(): void;
    flatten(): RustOption<T>;
    [Symbol.iterator](): Iterator<T>;
    toJSON(): object;
    equals(v: RustOption<T>): boolean;
}
export declare class RustResult<T, E> {
    private value;
    private error;
    static Ok(val: any): RustResult<typeof val, any>;
    static Err(err: any): RustResult<any, typeof err>;
    private constructor();
    isOk(): boolean;
    isErr(): boolean;
    ok(): RustOption<T>;
    err(): RustOption<E>;
    unwrap(): T;
    unwrapErr(): E;
    unwrapOr(def: T): T;
    unwrapOrElse(fn: (err: E) => T): T;
    map<U>(fn: (val: T) => U): RustResult<U, E>;
    mapErr<U>(fn: (err: E) => U): RustResult<T, U>;
    mapOr<U>(def: U, fn: (val: T) => U): U;
    mapOrElse<U>(fnErr: (err: E) => U, fnOk: (val: T) => U): U;
    match<U>(fn: ResultMatch<T, E, U>): U;
    contains(val: T): boolean;
    containsErr(err: E): boolean;
    expect(msg: string): T;
    expectErr(msg: string): E;
    iter(): Iterator<T>;
    and<U>(v: RustResult<U, E>): RustResult<U, E>;
    andThen<U>(fn: (val: T) => RustResult<U, E>): RustResult<U, E>;
    or<F>(v: RustResult<T, F>): RustResult<T, F>;
    orElse<F>(fn: (err: E) => RustResult<T, F>): RustResult<T, F>;
    cloned(): RustResult<T, E>;
    transpose(): RustOption<RustResult<T, E>>;
    [Symbol.iterator](): Iterator<T>;
    toString(): string;
    toJSON(): object;
    equals(v: RustResult<T, E>): boolean;
}
interface RustOptionBase<T> {
    transpose: <E>() => RustResult<RustOption<T>, E>;
    toString(): string;
}
export {};