/** One normalized placement: exactly one of `view` (a named view fills the
 *  slot) or `widget` (an inline spec, passed through verbatim for the host's
 *  evaluator). `span`/`label`/`note`/`with` are the placement's own words —
 *  they belong to THIS slot, never to the view definition it places. */
export interface PlacementEntry {
    view?: string;
    widget?: any;
    /** 1..12 of a 12-column grid; absent = full width (12) */
    span?: number;
    label?: string;
    note?: string;
    with?: Record<string, string>;
}
export interface PlacementSection {
    label?: string;
    /** markdown prose above the section's content (client renders it via the
     *  widget note channel today; the report surface owns richer treatment) */
    notes?: string;
    place: PlacementEntry[];
}
/** A grammar refusal. The host translates it to its own refusal type
 *  (DashboardError) so the CLI's authoring-mistake promise holds — this
 *  module stays import-free of the host precisely so BOTH surfaces
 *  (dashboard and report) can translate it their own way. */
export declare class PlacementError extends Error {
}
/** Placeholder names the ENGINE resolves late — the client substitutes them
 *  into rendered chrome (the grouped widget's callout resolves {documented}
 *  and {count} at draw time), so a `with:` supplying one would silently
 *  pre-empt a value the reader is supposed to see computed. A collision is a
 *  grammar refusal, not a finding: the author typed a reserved word into the
 *  file they are editing, and the fix is a rename. */
export declare const RESERVED_PLACEHOLDERS: ReadonlySet<string>;
/** The reserved screen ALONE, exported so the top-level reference form
 *  (dashboard.yaml `views: [{view, with}]`) refuses a reserved key with the
 *  SAME words as every placement — the hazard is identical at every nesting
 *  level (a `with: {documented: X}` silently pre-empts a value the engine
 *  resolves at draw time), so R7's one-grammar rule owns the message. Kept
 *  separate from checkWith because the top-level form's SHAPE mistakes stay
 *  warn-and-ignore (view-ref-invalid, t1's shipped behavior) — only the
 *  silent-corruption case escalates to a refusal. */
export declare function checkReservedWith(raw: unknown, where: string): void;
/**
 * One raw `place:` entry → one PlacementEntry. The three spellings:
 *   · bare string            ≡ { view: <name> }
 *   · { view: <name>, … }    the explicit form (span · label · note · with)
 *   · { widget: …, span? }   an inline widget spec, passed through VERBATIM —
 *     except `span:`, which is a placement word this grammar owns (leaving it
 *     on the spec would trip the widget's own unknown-key refusal with a
 *     misleading "not part of the board yet" answer), and except
 *     `{widget: view, use: <name>}`, which is the widgets-list spelling of a
 *     view placement and normalizes to the same `{view}` entry.
 */
export declare function normalizePlacementEntry(raw: any, where: string): PlacementEntry;
/**
 * Parse a `sections:` body. Every violation refuses: this is the file being
 * authored, and a half-parsed layout would render something the author never
 * wrote. `place: []` is legal — a label+notes section is a prose divider —
 * but a section WITHOUT place: is refused rather than defaulted, because an
 * author who wrote `widgets:` under a section (the sibling grammar) must hear
 * which word this grammar wants.
 */
export declare function parsePlacement(raw: any, where: string): PlacementSection[];
/**
 * The `widgets:` sugar: `widgets: [a, b]` IS `sections: [{place: [a, b]}]`
 * (§1.3), one anonymous section, no wrapper emitted downstream. Entries stay
 * VERBATIM widget specs — the evaluator's vocabulary, refusals and all —
 * except `{widget: view, use: …}`, which normalizes to a view placement.
 * Plain-widget `span:` is NOT extracted here: span is a placement word, and
 * in a widgets: list only the view spelling is a placement — a `span:` on a
 * rows widget must keep meeting the widget layer's own unknown-key answer,
 * identically at top level and nested, or the two spellings drift apart.
 */
export declare function normalizeWidgets(list: any[], where: string): PlacementSection[];