import { JsonOption, JsonResult, LooseRecord } from "./types";
declare class __Option<A> {
    static P: {
        Some: <const A_1>(value: A_1) => {
            readonly tag: "Some";
            readonly value: A_1;
        };
        None: {
            readonly tag: "None";
        };
    };
    static Some: <A_1 = never>(value: A_1) => Option<A_1>;
    static None: <A_1 = never>() => Option<A_1>;
    static isOption: (value: unknown) => value is Option<unknown>;
    /**
     * Create an Option from a nullable value
     */
    static fromNullable: <A_1>(nullable: A_1 | null | undefined) => Option<A_1>;
    /**
     * Create an Option from a value | null
     */
    static fromNull: <A_1>(nullable: A_1 | null) => Option<A_1>;
    /**
     * Create an Option from a undefined | value
     */
    static fromUndefined: <A_1>(nullable: A_1 | undefined) => Option<A_1>;
    /**
     * Create an Option from a value & predicate
     */
    static fromPredicate<A, B extends A>(value: A, predicate: (value: A) => value is B): Option<B>;
    static fromPredicate<A>(value: A, predicate: (value: A) => boolean): Option<A>;
    /**
     * Turns an array of options into an option of array
     */
    static all: <Options extends [] | Option<any>[]>(options: Options) => Option<{ [K in keyof Options]: Options[K] extends Option<infer T> ? T : never; }>;
    /**
     * Turns an dict of options into a options of dict
     */
    static allFromDict: <Dict extends LooseRecord<Option<any>>>(dict: Dict) => Option<{ [K in keyof Dict]: Dict[K] extends Option<infer T> ? T : never; }>;
    static equals: <A_1>(a: Option<A_1>, b: Option<A_1>, equals: (a: A_1, b: A_1) => boolean) => boolean;
    static fromJSON: <A_1>(value: JsonOption<A_1>) => Some<A_1> | None<A_1>;
    /**
     * Returns the Option containing the value from the callback
     *
     * (Option\<A>, A => B) => Option\<B>
     */
    map<B>(this: Option<A>, func: (value: A) => B): Option<B>;
    /**
     * Returns the Option containing the value from the callback
     *
     * (Option\<A>, A => Option\<B>) => Option\<B>
     */
    flatMap<B>(this: Option<A>, func: (value: A) => Option<B>): Option<B>;
    /**
     * Returns the Option if its value matches the predicate, otherwise false
     *
     * (Option\<A>, A => boolean) => Option\<A>
     */
    filter<B extends A>(this: Option<A>, func: (value: A) => value is B): Option<B>;
    filter(this: Option<A>, func: (value: A) => boolean): Option<A>;
    /**
     * Returns the value. Use within `if (Option.isSome()) { ... }`
     */
    get(this: Some<A>): A;
    /**
     * Return the value if present, and the fallback otherwise
     *
     * (Option\<A>, A) => A
     * @deprecated
     */
    getWithDefault(this: Option<A>, defaultValue: A): A;
    /**
     * Return the value if present, and the fallback otherwise
     *
     * (Option\<A>, A) => A
     */
    getOr(this: Option<A>, defaultValue: A): A;
    /**
     * Return the value if present, and the fallback otherwise
     *
     * (Option\<A>, Option\<A>) => Option\<A>
     */
    orElse(this: Option<A>, other: Option<A>): Option<A>;
    /**
     * Maps the value if present, returns the fallback otherwise
     *
     * (Option\<A>, B, A => B) => B
     */
    mapOr<B>(this: Option<A>, defaultValue: B, mapper: (value: A) => B): B;
    /**
     * Explodes the Option given its case
     */
    match<B1, B2 = B1>(this: Option<A>, config: {
        Some: (value: A) => B1;
        None: () => B2;
    }): B1 | B2;
    /**
     * Runs the callback and returns `this`
     */
    tap(this: Option<A>, func: (option: Option<A>) => unknown): Option<A>;
    /**
     * Runs the callback if some and returns `this`
     */
    tapSome(this: Option<A>, func: (option: A) => unknown): Option<A>;
    /**
     * Converts the Option\<A> to a `A | undefined`
     */
    toUndefined(this: Option<A>): A | undefined;
    /**
     * Converts the Option\<A> to a `A | null`
     */
    toNull(this: Option<A>): A | null;
    /**
     * Takes the option and turns it into Ok(value) is Some, or Error(valueWhenNone)
     */
    toResult<E>(this: Option<A>, valueWhenNone: E): Result<A, E>;
    /**
     * Typeguard
     */
    isSome(this: Option<A>): this is Some<A>;
    /**
     * Typeguard
     */
    isNone(this: Option<A>): this is None<A>;
    toJSON(this: Option<A>): JsonOption<A>;
}
interface Some<A> extends __Option<A> {
    readonly tag: "Some";
    readonly value: A;
}
interface None<A> extends __Option<A> {
    readonly tag: "None";
}
export declare const Option: typeof __Option;
export type Option<A> = Some<A> | None<A>;
declare class __Result<A, E> {
    static P: {
        Ok: <const A_1>(value: A_1) => {
            readonly tag: "Ok";
            readonly value: A_1;
        };
        Error: <const E_1>(error: E_1) => {
            readonly tag: "Error";
            readonly error: E_1;
        };
    };
    static Ok: <A_1 = never, E_1 = never>(value: A_1) => Result<A_1, E_1>;
    static Error: <A_1 = never, E_1 = never>(error: E_1) => Result<A_1, E_1>;
    static isResult: (value: unknown) => value is Result<unknown, unknown>;
    /**
     * Runs the function and resolves a result of its return value, or to an error if thrown
     */
    static fromExecution: <A_1, E_1 = unknown>(func: () => A_1) => Result<A_1, E_1>;
    /**
     * Takes the promise and resolves a result of its value, or to an error if rejected
     */
    static fromPromise: <A_1, E_1 = unknown>(promise: Promise<A_1>) => Promise<Result<A_1, E_1>>;
    /**
     * Takes the option and turns it into Ok(value) is Some, or Error(valueWhenNone)
     */
    static fromOption: <A_1, E_1>(option: Option<A_1>, valueWhenNone: E_1) => Result<A_1, E_1>;
    /**
     * Turns an array of results into an result of array
     */
    static all: <Results extends [] | Result<any, any>[]>(results: Results) => Result<{ [K in keyof Results]: Results[K] extends Result<infer T, any> ? T : never; }, { [K_1 in keyof Results]: Results[K_1] extends Result<any, infer T_1> ? T_1 : never; }[number]>;
    /**
     * Turns an dict of results into a results of dict
     */
    static allFromDict: <Dict extends LooseRecord<Result<any, any>>>(dict: Dict) => Result<{ [K in keyof Dict]: Dict[K] extends Result<infer T, any> ? T : never; }, { [K_1 in keyof Dict]: Dict[K_1] extends Result<any, infer T_1> ? T_1 : never; }[keyof Dict]>;
    static equals: <A_1, E_1>(a: Result<A_1, E_1>, b: Result<A_1, E_1>, equals: (a: A_1, b: A_1) => boolean) => boolean;
    static fromJSON: <A_1, E_1>(value: JsonResult<A_1, E_1>) => Result<A_1, E_1>;
    /**
     * Returns the Result containing the value from the callback
     *
     * (Result\<A, E>, A => B) => Result\<B>
     */
    map<B>(this: Result<A, E>, func: (value: A) => B): Result<B, E>;
    /**
     * Returns the Result containing the error returned from the callback
     *
     * (Result\<A, E>, E => F) => Result\<F>
     */
    mapError<F>(this: Result<A, E>, func: (value: E) => F): Result<A, F>;
    /**
     * Returns the Result containing the value from the callback
     *
     * (Result\<A, E>, A => Result\<B, F>) => Result\<B, E | F>
     */
    flatMap<B, F>(this: Result<A, E>, func: (value: A) => Result<B, F>): Result<B, F | E>;
    /**
     * Returns the Result containing the value from the callback
     *
     * (Result\<A, E>, E => Result\<A, F>) => Result\<A | B, F>
     */
    flatMapError<B, F>(this: Result<A, E>, func: (value: E) => Result<B, F>): Result<A | B, F>;
    /**
     * Returns the value. Use within `if (result.isOk()) { ... }`
     */
    get(this: Ok<A, E>): A;
    /**
     * Returns the error. Use within `if (result.isError()) { ... }`
     */
    getError(this: Error<A, E>): E;
    /**
     * Return the value if present, and the fallback otherwise
     *
     * (Result\<A, E>, A) => A
     * @deprecated
     */
    getWithDefault(this: Result<A, E>, defaultValue: A): A;
    /**
     * Return the value if present, and the fallback otherwise
     *
     * (Result\<A, E>, A) => A
     */
    getOr(this: Result<A, E>, defaultValue: A): A;
    /**
     * Maps the value if present, returns the fallback otherwise
     *
     * (Result\<A, E>, B, A => B) => B
     */
    mapOr<B>(this: Result<A, E>, defaultValue: B, mapper: (value: A) => B): B;
    /**
     * Explodes the Result given its case
     */
    match<B1, B2 = B1>(this: Result<A, E>, config: {
        Ok: (value: A) => B1;
        Error: (error: E) => B2;
    }): B1 | B2;
    /**
     * Runs the callback and returns `this`
     */
    tap(this: Result<A, E>, func: (result: Result<A, E>) => unknown): Result<A, E>;
    /**
     * Runs the callback if ok and returns `this`
     */
    tapOk(this: Result<A, E>, func: (value: A) => unknown): Result<A, E>;
    /**
     * Runs the callback if error and returns `this`
     */
    tapError(this: Result<A, E>, func: (error: E) => unknown): Result<A, E>;
    /**
     * Return an option of the value
     *
     * (Result\<A, E>) => Option\<A>
     */
    toOption(this: Result<A, E>): Option<A>;
    /**
     * Typeguard
     */
    isOk(this: Result<A, E>): this is Ok<A, E>;
    /**
     * Typeguard
     */
    isError(this: Result<A, E>): this is Error<A, E>;
    toJSON(this: Result<A, E>): JsonResult<A, E>;
}
interface Ok<A, E> extends __Result<A, E> {
    readonly tag: "Ok";
    readonly value: A;
}
interface Error<A, E> extends __Result<A, E> {
    readonly tag: "Error";
    readonly error: E;
}
export declare const Result: typeof __Result;
export type Result<A, E> = Ok<A, E> | Error<A, E>;
export {};