import type { Subscriber, Unsubscriber } from './types.js';
type StartStopNotifier<T> = (set: Subscriber<T>, update: (fn: Updater<T>) => void) => Unsubscriber | void;
export type Updater<T> = (value: T) => T;
export type { Subscriber, Unsubscriber };
export interface ReadonlyStore<T> {
    /**
     * Return the current value.
     */
    readonly state: T;
    /**
     * Subscribe to changes with a callback. Returns an unsubscribe function.
     * Pass `false` as the second argument to skip the immediate initial call.
     */
    subscribe(callback: Subscriber<T>, noInit?: false): Unsubscriber;
}
export interface Store<T> extends ReadonlyStore<T> {
    /**
     * Get or set the current value.
     */
    state: T;
}
/**
 * Clear the global reactive store context. Useful for testing to ensure a clean state between tests.
 */
export declare function clearAllContext(): void;
export declare class ReadonlyStoreClass<T> {
    #private;
    constructor(initialValue?: T, start?: StartStopNotifier<T>);
    get state(): T;
    protected set state(value: T);
    /**
     * Subscribe to changes with a callback. Returns an unsubscribe function.
     * Pass `false` as the second argument to skip the immediate initial call.
     */
    subscribe: (callback: Subscriber<T>, noInit?: false) => Unsubscriber;
}
export declare class StoreClass<T> extends ReadonlyStoreClass<T> {
    get state(): T;
    set state(value: T);
}
/**
 * Creates a `ReadonlyStore` that allows reading by subscription.
 */
export declare function readonly<T>(initialValue?: T, start?: StartStopNotifier<T>): ReadonlyStore<T>;
/**
 * Create a `Store` that allows both updating and reading by subscription.
 */
export declare function store<T>(value: T, start?: StartStopNotifier<T>): Store<T>;
/**
 * Watch stores and computed values by running a function whenever any stores accessed within it change.
 */
export declare function watch<T>(fn: (priorReturn: T) => T): Unsubscriber;
/**
 * Create a `ReadonlyStore` that computes its value from other stores and updates when those stores change.
 */
export declare function computed<T>(fn: (priorValue: T) => T, value?: T): ReadonlyStore<T>;
/**
 * Allows setting multiple stores at once and only notifying subscribers once after the batch function is run.
 */
export declare function batch(fn: () => void): void;
/**
 * Provides a promise that resolves when the store is no longer `null` or `undefined`.
 */
export declare function whenReady<T>(store: ReadonlyStore<T>): Promise<T>;
/**
 * Provides a promise that resolves when the store's value meets the provided condition.
 */
export declare function whenMatches<T>(store: ReadonlyStore<T>, matches: (value: T) => boolean): Promise<T>;
/**
 * Provides a promise that resolves after the store changes and returns the new value.
 */
export declare function afterChange<T>(store: ReadonlyStore<T>): Promise<T>;