export declare namespace Op {
    type Status = "loading" | "error" | "ready";
    type Loading = {
        status: "loading";
    };
    type Error = {
        status: "error";
        reason: string;
    };
    type Ready<X> = {
        status: "ready";
        payload: X;
    };
    type For<X> = Loading | Error | Ready<X>;
    type Setter<X> = (op: For<X>) => void;
    type Payload<O> = O extends Op.Ready<infer X> ? X : never;
    const loading: <X>() => For<X>;
    const error: <X>(reason: string) => For<X>;
    const ready: <X>(payload: X) => For<X>;
    const is: Readonly<{
        loading: (op: For<any>) => op is Op.Loading;
        error: (op: For<any>) => op is Op.Error;
        ready: <X>(op: For<X>) => op is Op.Ready<X>;
    }>;
    function payload<X>(op: For<X>): X | undefined;
    function reason<X>(op: For<X>): string | undefined;
    type Choices<X, R> = {
        loading: () => R;
        error: (reason: string) => R;
        ready: (payload: X) => R;
    };
    function select<X, R>(op: For<X>, choices: Choices<X, R>): R;
    function load<X>(set_op: Setter<X>, operation: () => Promise<X>): Promise<X>;
    function morph<A, B>(op: For<A>, transmute: (a: A) => B): For<B>;
    function all<O extends For<any>[]>(...ops: O): For<{ [K in keyof O]: Payload<O[K]>; }>;
}