/**
 * Which payload fields an "approve always here" policy rule pins, per
 * effect. Filled by generated code: each `effect` declaration carrying an
 * `@always` / `@alwaysUnder` tag compiles to one `__registerAlwaysScope`
 * call at module JS-load. Read by `std::policy` when it builds a scoped
 * rule and when it decides whether to offer the option at all.
 *
 * Process-wide and derived from code, like `crossModuleInitRegistry.ts`.
 * Never checkpointed: a resume re-imports the modules and re-registers.
 */
export type ScopedField = {
    field: string;
    matchSubpaths: boolean;
};
/** Same fields, in any order. The typechecker and the registry share this
 *  so "these two declarations agree" means one thing. */
export declare function sameScopedFields(a: ScopedField[], b: ScopedField[]): boolean;
/**
 * Take a scope that arrived from a subprocess with one of its interrupts.
 * The child is untrusted, so this never throws and never replaces a scope
 * this process already holds from its own compiled declarations: it fills
 * a gap only. A malformed value is ignored. The prompt still shows the
 * exact fields any rule would pin, and a scope whose fields the payload
 * lacks yields no rule at all (see `buildScopedMatch` in std::policy).
 */
export declare function adoptAlwaysScope(effect: string, fields: unknown): void;
export declare function __registerAlwaysScope(effect: string, fields: ScopedField[]): void;
export declare function alwaysScopeFor(effect: string): ScopedField[];
export declare function allAlwaysScopes(): Record<string, ScopedField[]>;