import { Option, Result } from "./OptionResult";
import { JsonAsyncData, LooseRecord } from "./types";
declare class __AsyncData<A> {
    static P: {
        Done: <const A_1>(value: A_1) => {
            readonly tag: "Done";
            readonly value: A_1;
        };
        NotAsked: {
            readonly tag: "NotAsked";
        };
        Loading: {
            readonly tag: "Loading";
        };
    };
    /**
     * Create an AsyncData.Done value
     */
    static Done: <A_1 = never>(value: A_1) => AsyncData<A_1>;
    /**
     * Create an AsyncData.Loading value
     */
    static Loading: <A_1 = never>() => AsyncData<A_1>;
    /**
     * Create an AsyncData.NotAsked value
     */
    static NotAsked: <A_1 = never>() => AsyncData<A_1>;
    /**
     * Turns an array of asyncData into an asyncData of array
     */
    static all: <AsyncDatas extends [] | AsyncData<any>[]>(asyncDatas: AsyncDatas) => AsyncData<{ [K in keyof AsyncDatas]: AsyncDatas[K] extends AsyncData<infer T> ? T : never; }>;
    /**
     * Turns an dict of asyncData into a asyncData of dict
     */
    static allFromDict: <Dict extends LooseRecord<AsyncData<any>>>(dict: Dict) => AsyncData<{ [K in keyof Dict]: Dict[K] extends AsyncData<infer T> ? T : never; }>;
    static equals: <A_1>(a: AsyncData<A_1>, b: AsyncData<A_1>, equals: (a: A_1, b: A_1) => boolean) => boolean;
    static isAsyncData: (value: unknown) => value is AsyncData<unknown>;
    static fromJSON: <A_1>(value: JsonAsyncData<A_1>) => Done<A_1> | Loading<A_1> | NotAsked<A_1>;
    map<B>(this: AsyncData<A>, func: (value: A) => B): AsyncData<B>;
    flatMap<B>(this: AsyncData<A>, func: (value: A) => AsyncData<B>): AsyncData<B>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning a new result and returns an AsyncData with this new result
     */
    mapOkToResult<A, E, B, F>(this: AsyncData<Result<A, E>>, func: (value: A) => Result<B, F>): AsyncData<Result<B, F | E>>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Error value and returning a new result and returns an AsyncData with this new result
     */
    mapErrorToResult<A, E, B, F>(this: AsyncData<Result<A, E>>, func: (value: E) => Result<B, F>): AsyncData<Result<A | B, F>>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning a new ok value and returns an AsyncData resolving to this new result
     */
    mapOk<A, E, B>(this: AsyncData<Result<A, E>>, func: (value: A) => B): AsyncData<Result<B, E>>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Error value and returning a new error value and returns an AsyncData to this new result
     *
     */
    mapError<A, E, B>(this: AsyncData<Result<A, E>>, func: (value: E) => B): AsyncData<Result<A, B>>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning an AsyncData
     */
    flatMapOk<A, E, B, F>(this: AsyncData<Result<A, E>>, func: (value: A) => AsyncData<Result<B, F>>): AsyncData<Result<B, F | E>>;
    /**
     * For AsyncData<Result<*>>:
     *
     * Takes a callback taking the Error value and returning an AsyncData
     */
    flatMapError<A, E, B, F>(this: AsyncData<Result<A, E>>, func: (value: E) => AsyncData<Result<B, F>>): AsyncData<Result<A | B, F>>;
    /**
     * Returns the value. Use within `if (asyncData.isDone()) { ... }`
     */
    get(this: Done<A>): A;
    /**
     * @deprecated
     */
    getWithDefault(this: AsyncData<A>, defaultValue: A): A;
    getOr(this: AsyncData<A>, defaultValue: A): A;
    /**
     * Maps the value if present, returns the fallback otherwise
     *
     * (AsyncData\<A>, B, A => B) => B
     */
    mapOr<B>(this: AsyncData<A>, defaultValue: B, mapper: (value: A) => B): B;
    match<B1, B2 = B1, B3 = B1 | B2>(this: AsyncData<A>, config: {
        Done: (value: A) => B1;
        Loading: () => B2;
        NotAsked: () => B3;
    }): B1 | B2 | B3;
    tap(this: AsyncData<A>, func: (asyncData: AsyncData<A>) => unknown): AsyncData<A>;
    toOption(this: AsyncData<A>): Option<A>;
    isDone(this: AsyncData<A>): this is Done<A>;
    isLoading(this: AsyncData<A>): this is Loading<A>;
    isNotAsked(this: AsyncData<A>): this is NotAsked<A>;
    toJSON(this: AsyncData<A>): JsonAsyncData<A>;
}
interface Done<A> extends Readonly<__AsyncData<A>> {
    readonly tag: "Done";
    readonly value: A;
}
interface Loading<A> extends Readonly<__AsyncData<A>> {
    readonly tag: "Loading";
}
interface NotAsked<A> extends Readonly<__AsyncData<A>> {
    readonly tag: "NotAsked";
}
export declare const AsyncData: typeof __AsyncData;
export type AsyncData<A> = Done<A> | Loading<A> | NotAsked<A>;
export {};