export interface CatalogEntry {
    name: string;
    /** what it renders, or what it is for */
    about: string;
    /** where a definition declares it */
    where: string;
    /** the options it accepts */
    accepts?: string[];
}
/** Top-level views a navigation item can be. */
export declare const VIEWS: CatalogEntry[];
/** Prebuilt compositions, parameterised by `bind`. DEPRECATED as `use:` packs
 *  since 0.7.0 — the same binds live on the widget path now: stat-row with
 *  preset: traceability, and the coverage / reverse-gap widgets' own bind:. */
export declare const PACKS: CatalogEntry[];
/** What a query selects over. */
export declare const SELECTS: CatalogEntry[];
/** How a block presents at a given width. Absent = table. */
export declare const BLOCK_LAYOUTS: readonly ["table", "cards"];
export type BlockLayout = typeof BLOCK_LAYOUTS[number];
/** What a column becomes inside a card. Default `field` = labelled value. */
export declare const CARD_ROLES: readonly ["eyebrow", "title", "badge", "field", "hide"];
export type CardRole = typeof CARD_ROLES[number];
/** How a cell is drawn. */
export declare const COLUMN_STYLES: CatalogEntry[];
/** Inputs a form or a capture field can be. */
export declare const FIELD_KINDS: CatalogEntry[];
/** Controls that narrow what a view shows without changing its query. */
export declare const CONTROLS: CatalogEntry[];
/** Marks a chart series can draw over the CURRENT rows — one number per
 *  bucket of `x.by`. */
export declare const ROWS_MARKS: readonly ["bar", "line", "area", "dot"];
/** Marks a chart series can draw. The first four read the rows; the last four
 *  (E41) read the operational EVENT LOG through a `history:` binding, and the
 *  two halves refuse to share a chart — a rows mark on a history chart and a
 *  history mark on a rows chart are each a named load error, because the two
 *  compute over different x axes and a chart has one. */
export declare const CHART_MARKS: readonly ["bar", "line", "area", "dot", "burndown", "burnup", "flow", "cycle-time"];
export type ChartMark = typeof CHART_MARKS[number];
/** Widgets a composed view arranges. A view is an ORDERED LIST of these —
 *  the difference between picking a view from a menu and composing a UI. */
export declare const WIDGETS: CatalogEntry[];
/** E32 t2 — the placement grammar (design R7): ONE spelling for "put a view
 *  (or a widget) in a slot", shared by composite views' `sections:`, the
 *  `{widget: view}` entry above, and the report surface (t4). Grammar
 *  mistakes here REFUSE (the author is editing this file); whether a placed
 *  NAME resolves is the warn-level view-* family. */
export declare const PLACEMENT: CatalogEntry[];
/** E36 t1 — the plugins group: engine-shipped extensions a format installs by
 *  name (decision 0022's inversion: one line, works immediately). The group
 *  head carries the four rules of the contract; each plugin prints its
 *  DECLARED tier (L17) beside its prose; tombstoned names print the sentence
 *  that will answer them forever, so an agent reading the catalogue never has
 *  to discover a refusal by writing the line. */
export declare const PLUGIN_CATALOG: CatalogEntry[];
export interface VocabularyEntry {
    name: string;
    /** the format's own prose, verbatim — absent when it declared none */
    about?: string;
    /** where in the format definition it is declared */
    where: string;
}
/** The vocabulary ONE definition declares, grouped for a consumer to print.
 *  Groups are prefixed `format*` so they can never shadow an engine group,
 *  and an empty group is omitted rather than printed as a promise of nothing. */
export declare function formatVocabulary(def: {
    types: Record<string, {
        name: string;
        about?: string;
        required?: Record<string, {
            kind: string;
            values?: string[];
            about?: Record<string, string>;
        }>;
        optional?: Record<string, {
            kind: string;
            values?: string[];
            about?: Record<string, string>;
        }>;
    }>;
    blocks: Record<string, {
        name: string;
        heading: string;
        about?: string;
        tier?: string;
        /** E36 t6 — the dj/work binding; optional so hand-built vocab callers
         *  predating the field keep compiling */
        work?: {
            title: string;
            state?: string;
            closedWhen?: string[];
            people?: string;
            start?: string;
            due?: string;
        };
        columns: {
            key: string;
            nameRaw?: string;
            about?: string;
            enum?: string[];
            enumAbout?: Record<string, string>;
            /** E38 t1 — the declared relation this column carries; optional for the
             *  same hand-built-caller reason as work */
            relation?: string;
        }[];
    }>;
    /** E38 t1 — the relation vocabulary; optional so hand-built vocab callers
     *  predating the field keep compiling. loadDefinition always supplies it
     *  (possibly an empty Map). */
    relations?: ReadonlyMap<string, {
        name: string;
        label?: string;
        about?: string;
        direction: string;
        inverse?: string;
        to: string[];
        from: string[];
    }>;
    /** E36 t1 — optional so hand-built vocab callers predating the field keep
     *  compiling; loadDefinition always supplies it (possibly []) */
    plugins?: {
        name: string;
        plugin: {
            tier: string;
            about?: string;
        };
        /** PR13 — block → authored extension column names; absent when the
         *  format extended nothing (which keeps yesterday's print byte-exact) */
        extensions?: Record<string, string[]>;
    }[];
}): Record<string, VocabularyEntry[]>;
/** E38 t1 (rulings P4–P8) — the relations grammar: cross-document, typed,
 *  DIRECTED references between records. Vocabulary at the top level, carried
 *  by AUTHORED columns — nothing synthesized, no prefix reserved. */
export declare const RELATIONS: CatalogEntry[];
/** E41 — the HISTORY binding: a chart's second source. Everything here is a
 *  question about DECLARED STATE TRANSITIONS, so the engine ships the
 *  mechanism and the FORMAT supplies every word: which column carries the
 *  states, which of its declared values count as unfinished, finished or
 *  dropped. Nothing in this group knows what any of them mean. */
export declare const HISTORY: CatalogEntry[];
/** E32 t1 — named views: reusable view files under views/, placed by name.
 *  Warn-level family throughout (view-*): a library problem degrades the one
 *  view it touches — a stub page, a skipped file — and never kills the
 *  dashboard, while grammar mistakes in the file being authored stay refusals. */
export declare const NAMED_VIEWS: CatalogEntry[];
/** E32 t3 — the surface KINDS a YAML file can declare (decision 0019). One
 *  file per surface, self-declaring through the top-level `surface:` key;
 *  the four axes a kind carries (traversal · chrome · medium · ceiling) are
 *  prose HERE and code only where code reads them — SurfaceKind in
 *  surfaces/contract.ts is trimmed to {name, traversal, ceiling, slices}
 *  (ledger R10), and this group is where chrome and medium get their say. */
export declare const SURFACES: CatalogEntry[];
/** Top-level keys that shape a WHOLE SURFACE (any kind — dashboard.yaml and
 *  every `surface:`-declaring sibling alike), not one view. */
export declare const SURFACE: CatalogEntry[];
export declare const CATALOG: {
    surface: CatalogEntry[];
    surfaces: CatalogEntry[];
    navIcons: CatalogEntry[];
    widgets: CatalogEntry[];
    marks: CatalogEntry[];
    views: CatalogEntry[];
    namedViews: CatalogEntry[];
    placement: CatalogEntry[];
    packs: CatalogEntry[];
    selects: CatalogEntry[];
    layouts: CatalogEntry[];
    cardRoles: CatalogEntry[];
    columnStyles: CatalogEntry[];
    fieldKinds: CatalogEntry[];
    controls: CatalogEntry[];
    relations: CatalogEntry[];
    history: CatalogEntry[];
    plugins: CatalogEntry[];
};
export type CatalogGroup = keyof typeof CATALOG;