import { flushPromises } from './utils';
import { LooseTimeStrategyKind } from './time-strategy';
import { Option, State, StateChangePayload, StoreHooks, StoreOptions } from './types';
import type * as commands from "./commands";
/**
 * Base class for the store implementations.
 *
 * @internal
 */
export declare abstract class BaseStore<S extends State = State> {
    abstract readonly id: string;
    protected abstract readonly options: StoreOptions<S>;
    /** Whether the synchronization is enabled. */
    protected enabled: boolean;
    /** Queue of state changes to be processed. */
    protected changeQueue: StateChangePayload<S>[];
    /** Flushes pending promises. */
    protected readonly flush: typeof flushPromises;
    /** Starts the store synchronization. */
    start(): Promise<void>;
    /** Stops the store synchronization. */
    stop(): Promise<void>;
    /** Loads the store state from the backend. */
    protected abstract load(): Promise<void>;
    protected abstract unload(): Promise<void>;
    /** Watches itself for state changes, notifying the backend when necessary. */
    protected abstract watch(): () => void;
    /** Stops watching for changes in the store state. */
    protected unwatch: Option<() => void>;
    /** Listens for state changes coming from the backend. */
    protected listen(): Promise<() => void>;
    /** Stops listening for state changes coming from the backend. */
    protected unlisten: Option<() => void>;
    private listenOptions;
    private unlistenOptions;
    protected processChangeQueue(): Promise<void>;
    protected abstract patchSelf(state: S): void;
    protected abstract patchBackend(state: S): void;
    protected patchBackendHelper(fn: ReturnType<typeof commands.patch>, state: S): void;
    protected abstract setOptions(): Promise<void>;
    protected setOptionsHelper(fn: ReturnType<typeof commands.setStoreOptions>): Promise<void>;
    private patchOptions;
    protected applyKeyFilters(state: Partial<S>): Partial<S>;
    protected tryAutoStart(): Promise<void>;
    protected updateDenylist(f: {
        allowSave: ReturnType<typeof commands.allowSave>;
        allowSync: ReturnType<typeof commands.allowSync>;
        denySave: ReturnType<typeof commands.denySave>;
        denySync: ReturnType<typeof commands.denySync>;
    }): Promise<void>;
    /**
     * {@link StoreOptions.syncStrategy}
     */
    protected get syncStrategy(): LooseTimeStrategyKind;
    /**
     * {@link StoreOptions.saveStrategy}
     */
    protected get syncInterval(): Option<number>;
    /**
     * {@link StoreHooks.error}
     */
    protected get onError(): Option<StoreHooks<S>["error"]>;
}