import { type PluginDef } from './registry.js';
import type { Finding } from '../types.js';
/** One installed plugin inside a CompiledDefinition: the name the format
 *  wrote and the resolved registry entry (or the test-injected fixture) —
 *  carried whole so every consumer (engineViews, the catalogue, a host
 *  provisioner reading the compiled definition) answers from the same
 *  resolution instead of re-looking the name up against a registry that may
 *  have moved. */
export interface InstalledPlugin {
    name: string;
    plugin: PluginDef;
    /** PR13 — the extension record: block name → the AUTHORED column names this
     *  format added via extend: (the compiled keys are x_<name>). Present only
     *  when an extension actually compiled, so an install without extend: stays
     *  deep-equal to the shape it had before the field existed — and the
     *  catalogue can print what THIS format extended without re-deriving it
     *  from the compiled columns. */
    extensions?: Record<string, string[]>;
}
export interface ParsedPlugins {
    installed: InstalledPlugin[];
    /** plugin-contributed blocks as RAW configs (extension columns already
     *  namespaced and appended), keyed by block name — the loader compiles
     *  them with its own loop, after the format's blocks */
    blocks: Record<string, any>;
}
type SuggestFn = (key: string, siblings: string[]) => string;
/**
 * Parse and validate `plugins:`. `registry` defaults to the shipped closed
 * set; tests inject a map to prove the extension mechanism (PR13's doctrine —
 * no shipped plugin is extendable, so the three extend findings are otherwise
 * unreachable) and the L1/L17 asserts, never to widen what a real format may
 * install.
 */
export declare function parsePlugins(raw: unknown, findings: Finding[], suggest: SuggestFn, registry?: ReadonlyMap<string, PluginDef>): ParsedPlugins;
export {};