import { CancelToken } from 'axios';
export declare type Cancel = (reason?: string, info?: any) => void;
export declare type PayloadState = 'nothing' | 'value' | 'loading' | 'error';
export declare const PayloadState: {
    Nothing: "nothing";
    Value: "value";
    Loading: "loading";
    Error: "error";
};
export declare abstract class PayloadBase<T> {
    abstract match<R>(matcher: PayloadMatcher<T, R>): R;
    isReady(matcher?: Partial<PayloadMatcher<T, boolean>>): boolean;
}
export declare class PayloadValue<T> extends PayloadBase<T> implements PayloadApi<T> {
    state: "value";
    value: T;
    meta: any;
    constructor(entity: T, meta?: any);
    isValue(this: Payload<T>): this is PayloadValue<T>;
    isLoading(this: Payload<T>): this is PayloadLoading<T>;
    isError(this: Payload<T>): this is PayloadError<T>;
    isNothing(this: Payload<T>): this is PayloadNothing<T>;
    match<R>(matcher: PayloadMatcher<T, R>): R;
    andThen<U>(op: (a: T) => Payload<U>): Payload<U>;
    map<U>(op: (a: T) => U): Payload<U>;
    orElse(_: (a: Error) => Payload<T>): Payload<T>;
    unwrapOr<R>(_or: R): T | R;
    unwrapOrElse<R>(_: (e?: Error) => R): T | R;
}
export declare class PayloadLoading<T> extends PayloadBase<T> implements PayloadApi<T> {
    __brand: T;
    state: "loading";
    meta: any;
    cancel: () => void;
    constructor(cancel?: Cancel, meta?: {});
    isValue(this: Payload<T>): this is PayloadValue<T>;
    isLoading(this: Payload<T>): this is PayloadLoading<T>;
    isError(this: Payload<T>): this is PayloadError<T>;
    isNothing(this: Payload<T>): this is PayloadNothing<T>;
    match<R>(matcher: PayloadMatcher<T, R>): R;
    andThen<U>(_op: (a: T) => Payload<U>): Payload<U>;
    map<U>(_op: (a: T) => U): Payload<U>;
    unwrapOr<R>(def: R): T | R;
    unwrapOrElse<R>(def: (e?: Error) => R): T | R;
}
export declare class PayloadError<T> extends PayloadBase<T> implements PayloadApi<T> {
    __brand: T;
    state: "error";
    meta: any;
    error: Error;
    constructor(error: Error, meta?: {});
    isValue(this: Payload<T>): this is PayloadValue<T>;
    isLoading(this: Payload<T>): this is PayloadLoading<T>;
    isError(this: Payload<T>): this is PayloadError<T>;
    isNothing(this: Payload<T>): this is PayloadNothing<T>;
    unwrapOr<R>(def: R): T | R;
    unwrapOrElse<R>(def: (error?: Error) => R): T | R;
    map<U>(_op: (a: T) => U): Payload<U>;
    andThen<U>(_op: (a: T) => Payload<U>): Payload<U>;
    match<R>(matcher: PayloadMatcher<T, R>): R;
}
export declare class PayloadNothing<T> extends PayloadBase<T> implements PayloadApi<T> {
    __brand: T;
    state: "nothing";
    meta: any;
    constructor(meta?: {});
    isValue(this: Payload<T>): this is PayloadValue<T>;
    isLoading(this: Payload<T>): this is PayloadLoading<T>;
    isError(this: Payload<T>): this is PayloadError<T>;
    isNothing(this: Payload<T>): this is PayloadNothing<T>;
    unwrapOr<R>(def: R): T | R;
    unwrapOrElse<R>(def: (error?: Error) => R): T | R;
    andThen<U>(_op: (a: T) => Payload<U>): Payload<U>;
    map<U>(_op: (a: T) => U): Payload<U>;
    match<R>(matcher: PayloadMatcher<T, R>): R;
}
export interface PayloadApi<T> {
    state: PayloadState;
    isValue(this: Payload<T>): this is PayloadValue<T>;
    isLoading(this: Payload<T>): this is PayloadLoading<T>;
    isError(this: Payload<T>): this is PayloadError<T>;
    isNothing(this: Payload<T>): this is PayloadNothing<T>;
    match<R>(matcher: PayloadMatcher<T, R>): R;
    isReady(matcher?: Partial<PayloadMatcher<T, boolean>>): boolean;
    andThen<U>(op: (a: T) => Payload<U>): Payload<U>;
    map<U>(op: (a: T) => U): Payload<U>;
    unwrapOr<R>(or: R): T | R;
    unwrapOrElse<R>(or: (e?: Error) => R): T | R;
}
export declare type Payload<T> = PayloadValue<T> | PayloadError<T> | PayloadLoading<T> | PayloadNothing<T>;
export declare function all<T>(payloads: Payload<T>[]): Payload<T[]>;
export declare const Payload: {
    State: {
        Nothing: "nothing";
        Value: "value";
        Loading: "loading";
        Error: "error";
    };
    Value: typeof PayloadValue;
    Loading: typeof PayloadLoading;
    Error: typeof PayloadError;
    Nothing: typeof PayloadNothing;
    isError: typeof isError;
    isValue: typeof isValue;
    isNothing: typeof isNothing;
    isLoading: typeof isLoading;
    fromPromise: typeof fromPromise;
    all: typeof all;
};
export default Payload;
export declare function isValue<T>(load: Payload<T>): load is PayloadValue<T>;
export declare function isLoading<T>(load: Payload<T>): load is PayloadLoading<T>;
export declare function isError<T>(load: Payload<T>): load is PayloadError<T>;
export declare function isNothing<T>(load: Payload<T>): load is PayloadNothing<T>;
export interface PayloadMatcher<T, R> {
    Nothing: () => R;
    Value: (entity: T) => R;
    Loading: (cancel: Cancel) => R;
    Error: (error: Error) => R;
}
export declare function cancellify<T>(promise: Promise<T>, cancelToken: CancelToken): Promise<T>;
export declare function fromPromise<T>(opts: {
    promise: Promise<T>;
    cancel?: Cancel;
    cancellable?: boolean;
    update: (p: Payload<T>) => void;
}): Promise<T>;
//# sourceMappingURL=payload.d.ts.map