/**
 * Where an operator's config overrides survive a process.
 *
 * In `store/` rather than beside the registry, and shaped like its
 * neighbours, because the alternative is a second persistence mechanism in a
 * tree that already has one — and two ways to write durable state is two
 * places to get a path, a permission or an encoding wrong.
 *
 * **Synchronous, deliberately.** `ConfigScope.get()` is read on every
 * reconnect attempt and inside a supervisor's backoff loop, so a config read
 * cannot be a promise without making every consumer async for a value that
 * is already in memory. The store is read ONCE at construction and written
 * through on update, which is what makes that possible.
 */
export interface ConfigOverrideStore {
    /** Everything previously written, keyed by namespace. Read once. */
    load(): Record<string, unknown>;
    /** Persist one namespace's accumulated override. */
    save(namespace: string, override: unknown): void;
}
/** The default: nothing survives the process, and it says so by its name. */
export declare class InMemoryConfigOverrideStore implements ConfigOverrideStore {
    private readonly overrides;
    load(): Record<string, unknown>;
    save(namespace: string, override: unknown): void;
}
/**
 * One JSON file, rewritten whole on every save.
 *
 * Whole-file rather than append-and-replay: this holds tens of small
 * objects, not a log, and a rewrite is the shape a human can open and read.
 * A corrupt file loads as empty rather than throwing — a config override is
 * a preference, and refusing to start a turn because one is unreadable would
 * make a convenience into an outage.
 */
export declare class DiskConfigOverrideStore implements ConfigOverrideStore {
    private readonly path;
    private cache;
    constructor(path: string);
    load(): Record<string, unknown>;
    save(namespace: string, override: unknown): void;
}
//# sourceMappingURL=index.d.ts.map