import type { FastContext } from "../createFastContext";
export declare function useValue<S extends object, A, K extends keyof S>(context: FastContext<S, A>, key: K): S[K];
export declare function useShallow<S extends object, A, R>(context: FastContext<S, A>, selector: (s: S) => R): R;
export declare function useComputed<S extends object, A, R>(context: FastContext<S, A>, selector: (s: S) => R, equality?: (a: R, b: R) => boolean): R;
export declare function useActions<S extends object, A>(context: FastContext<S, A>): A;
export declare function useWatch<S extends object, A, R>(context: FastContext<S, A>, selector: (state: S) => R, effect: (value: R, prev: R | undefined) => void, equality?: (a: R, b: R) => boolean): void;
export declare function useWhen<S extends object, A, R>(context: FastContext<S, A>, predicate: (state: S) => R, effect: (value: R, state: S) => void): void;
export declare function useAsyncStatus<S extends object, A, LK extends keyof S, EK extends keyof S>(context: FastContext<S, A>, loadingKey: LK, errorKey?: EK): {
    loading: S[LK];
    error: S[EK] | undefined;
};
export declare function extendContext<S extends object, A>(context: FastContext<S, A>): {
    useValue: <K extends keyof S>(key: K) => S[K];
    useShallow: <R>(selector: (s: S) => R) => R;
    useComputed: <R>(selector: (s: S) => R, equality?: (a: R, b: R) => boolean) => R;
    useActions: () => A;
    useWatch: <R>(selector: (state: S) => R, effect: (value: R, prev: R | undefined) => void, equality?: (a: R, b: R) => boolean) => void;
    useWhen: <R>(predicate: (state: S) => R, effect: (value: R, state: S) => void) => void;
    useAsyncStatus: <LK extends keyof S, EK extends keyof S | undefined = undefined>(loadingKey: LK, errorKey?: EK) => {
        loading: S[LK];
        error: S[keyof S] | undefined;
    };
    state(): S;
    get(): S;
    set: (updater: (s: S) => void) => void;
    replace: (next: S) => void;
    batch: import("..").Store<S_1>["batch"];
    transaction: import("..").Store<S_1>["transaction"];
    subscribe: import("..").Store<S_1>["subscribe"];
    update(fn: (state: S) => void): void;
    commit(fn: (state: S) => void): void;
    use: <T = S>(selector?: ((state: S) => T) | undefined, equality?: ((a: T, b: T) => boolean) | undefined) => T;
    useState(): S;
    computed: <R>(selector: (s: S) => R, equality?: ((a: R, b: R) => boolean) | undefined) => {
        use(): R;
        value(): R;
        subscribe(callback: (value: R) => void): () => void;
    };
    select: <R>(selector: (s: S) => R, equality?: ((a: R, b: R) => boolean) | undefined) => {
        use(): R;
        value(): R;
        subscribe(callback: (value: R) => void): () => void;
    };
    peek<T = S>(selector?: ((state: S) => T) | undefined): T;
    when: <R>(predicate: (state: S) => R, effect: (value: R, state: S) => void) => () => void;
    watch<R>(selector: (state: S) => R, effect: (value: R, prev: R | undefined) => void, equality?: ((a: R, b: R) => boolean) | undefined): () => void;
    scope(state: S, options?: {
        merge?: import("..").MergeMode;
    }): FastContext<S, A>;
    devtools: (callback: (info: {
        state: S;
    }) => void) => () => void;
    actions: A extends import("..").StateActionMap<S> ? { [K in keyof A]: (...args: Parameters<A[K]> extends [any, ...infer P] ? P : never) => void; } : undefined;
};