/**
 * A type for handling the states of remote (potential) data.
 */
import * as option from "fp-ts/lib/Option";
/**
 * Empty value, not yet retrieved.
 */
interface None {
    readonly kind: "PotNone";
}
export declare const none: None;
/**
 * Empty value, loading.
 */
interface NoneLoading {
    readonly kind: "PotNoneLoading";
}
export declare const noneLoading: NoneLoading;
/**
 * Empty value, updating a new value to remote store.
 */
interface NoneUpdating<T> {
    readonly kind: "PotNoneUpdating";
    readonly newValue: T;
}
export declare const noneUpdating: <T>(newValue: T) => NoneUpdating<T>;
/**
 * Empty value, loading failed.
 */
interface NoneError<E> {
    readonly kind: "PotNoneError";
    readonly error: E;
}
export declare const noneError: <E>(error: E) => NoneError<E>;
/**
 * Loaded value.
 */
interface Some<T> {
    readonly kind: "PotSome";
    readonly value: T;
}
export declare const some: <T>(value: T) => Some<T>;
/**
 * Loaded value, loading a new value from remote.
 */
interface SomeLoading<T> {
    readonly kind: "PotSomeLoading";
    readonly value: T;
}
export declare const someLoading: <T>(value: T) => SomeLoading<T>;
/**
 * Loaded value, updating a new value to remote store.
 */
interface SomeUpdating<T> {
    readonly kind: "PotSomeUpdating";
    readonly value: T;
    readonly newValue: T;
}
export declare const someUpdating: <T>(value: T, newValue: T) => SomeUpdating<T>;
/**
 * Loaded value, loading an updated value failed.
 */
interface SomeError<T, E> {
    readonly kind: "PotSomeError";
    readonly value: T;
    readonly error: E;
}
export declare const someError: <T, E>(value: T, error: E) => SomeError<T, E>;
export declare type Pot<T, E> = None | NoneLoading | NoneUpdating<T> | NoneError<E> | Some<T> | SomeLoading<T> | SomeUpdating<T> | SomeError<T, E>;
export declare type PotType<T> = T extends Some<infer A0> ? A0 : T extends SomeLoading<infer A1> ? A1 : T extends SomeError<infer A2, any> ? A2 : never;
export declare type PotErrorType<T> = T extends NoneError<infer E0> ? E0 : T extends SomeError<any, infer E1> ? E1 : never;
export declare const toSomeLoading: <T>(p: Some<T> | SomeError<T, any>) => SomeLoading<T>;
export declare const isSome: <A, E = unknown>(p: Pot<A, E>) => p is Some<A> | SomeLoading<A> | SomeUpdating<A> | SomeError<A, E>;
export declare const isNone: <A, E = unknown>(p: Pot<A, E>) => p is None | NoneLoading | NoneUpdating<A> | NoneError<E>;
export declare const isLoading: <A>(p: Pot<A, any>) => p is NoneLoading | SomeLoading<A>;
export declare const isUpdating: <A>(p: Pot<A, any>) => p is NoneUpdating<A> | SomeUpdating<A>;
export declare const isError: <A, E = unknown>(p: Pot<A, E>) => p is NoneError<E> | SomeError<A, E>;
export declare const toLoading: <T>(p: Pot<T, any>) => NoneLoading | SomeLoading<T>;
export declare const toUpdating: <T>(p: Pot<T, any>, newValue: T) => SomeUpdating<T> | NoneUpdating<T>;
export declare const toError: <T, E = unknown>(p: Pot<T, E>, error: E) => NoneError<E> | SomeError<T, E>;
export declare const fold: <A, E, O>(p: Pot<A, E>, foldNone: () => O, foldNoneLoading: () => O, foldNoneUpdating: (newValue: A) => O, foldNoneError: (error: E) => O, foldSome: (value: A) => O, foldSomeLoading: (value: A) => O, foldSomeUpdating: (value: A, newValue: A) => O, foldSomeError: (value: A, error: E) => O) => O;
export declare const map: <A, B, E = unknown>(p: Pot<A, E>, f: (_: A) => B) => Pot<B, E>;
export declare const filter: <A, E = unknown>(p: Pot<A, E>, f: (v: A) => boolean) => Pot<A, E>;
export declare const mapNullable: <A, B, E = unknown>(p: Pot<A, E>, f: (_: A) => B | null | undefined) => Pot<B, E>;
export declare const getOrElse: <A>(p: Pot<A, any>, o: A) => A;
export declare const getOrElseWithUpdating: <A>(p: Pot<A, any>, o: A) => A;
export declare const orElse: <A, E = unknown>(p: Pot<A, E>, o: Pot<A, E>) => Pot<A, E>;
export declare const toUndefined: <A>(p: Pot<A, any>) => A | undefined;
export declare const toOption: <A>(p: Pot<A, any>) => option.Option<A>;
export declare const isPot: (value: any) => value is Pot<any, any>;
export {};