/**
 * Single source of truth for the global kill switch.
 *
 * Background: prior to v0.5.6 the server held its own `killSwitchActive`
 * boolean while every `PermissionEngine` instance kept a private copy that
 * was snapshotted at construction time. Per-session engines therefore could
 * not see kill-switch changes made after the session started; conversely,
 * code that called `engine.engageKillSwitch()` directly never propagated
 * back to the server flag the schedulers were reading. Audit item #6
 * captured this drift risk.
 *
 * `KillSwitch` centralises the state. The server owns one instance; the
 * permission engine accepts that instance and reads through it on every
 * `evaluate()` call, so every consumer always sees live state.
 *
 * Persistence stays the same: the server snapshots and restores via
 * `snapshot()` / `restore()` against `settings.json`.
 */
export interface KillSwitchState {
    active: boolean;
    reason: string;
}
export type KillSwitchListener = (state: KillSwitchState) => void;
export declare class KillSwitch {
    private state;
    private listeners;
    isActive(): boolean;
    getReason(): string;
    /** Return a defensive copy so callers cannot mutate internal state. */
    snapshot(): KillSwitchState;
    /**
     * Engage the kill switch with an optional human-readable reason. Idempotent
     * but always overwrites the reason so the most recent operator note wins.
     */
    engage(reason?: string): void;
    release(): void;
    /**
     * Restore from a persisted snapshot (e.g. `settings.json`). Does not fire
     * listeners — startup restoration is observed via the initial settings
     * load, not as a state-change event.
     */
    restore(snapshot: Partial<KillSwitchState> | null | undefined): void;
    /** Subscribe to engage/release transitions. Returns an unsubscribe fn. */
    onChange(listener: KillSwitchListener): () => void;
    private emit;
}
//# sourceMappingURL=killSwitch.d.ts.map