/**
 * Catalog builder — turns the component graph into an A2UI v1.0-shaped
 * catalog document (#1887, strategy §4.2 in docs/GENERATIVE-UI-STRATEGY.md).
 *
 * A catalog is what a *renderer* or a *composer* reads: every node an agent
 * may name, its props as JSON Schema, its slots as child lists, and the Eddie
 * tag each node maps to. It is generated from `.eddie-brain/components.json`
 * on every `eddie-brain init`, so it cannot drift from source, and it is
 * covered by the CI graph-freshness gate like the rest of the graph.
 *
 * Shape follows `specification/v1_0/json/catalog_definition.json` in
 * a2ui-project/a2ui: `catalogId`, `protocolVersion`, `instructions`, and a
 * `components` map whose values are JSON Schema objects carrying the
 * `allowedParents` / `allowedChildren` / `metadata.extensions` fields that
 * v1.0 added. Two rules from that spec shape everything here:
 *
 *   - **Node names are UAX #31 identifiers.** `ed-r-stat-card` is not a legal
 *     component name (hyphens fail `XID_Continue`), so nodes are `StatCard`
 *     and the tag lives in `metadata.extensions.eddie_tag`.
 *   - **`Surface` is reserved** as the root parent; a profile's composition
 *     nodes declare `allowedParents: ["Surface"]`.
 *
 * Three Eddie-level fields (`profile`, `contractComplete`, `eddieVersion`)
 * sit at the catalog root. `catalog_definition.json` declares
 * `additionalProperties: false` there, so a validator that checks the root
 * strictly will flag them; A2UI's own `assemble_catalog.py` does not (it
 * checks the document is a valid Draft 2020-12 schema). They stay at the
 * root because the approved spec names them there and consumers need
 * `contractComplete` before they trust containment. Revisit when v1.0
 * finalizes (Q4 2026) and offers a catalog-level extension slot.
 *
 * Deterministic on purpose: no timestamps. `eddieVersion` is the provenance.
 * A timestamp would make every `init` a git diff and break the freshness
 * gate (the same trap `metadata.json` fell into before it was gitignored).
 */
import type { AntiPattern, ComponentEntry, PropertyEntry, SlotEntry } from '../types.js';
/** A2UI v1.0 `common_types.json` — the child-reference schema every node uses. */
export declare const A2UI_COMMON_TYPES = "https://a2ui.org/specification/v1_0/common_types.json";
export declare const A2UI_CHILD_LIST = "https://a2ui.org/specification/v1_0/common_types.json#/$defs/ChildList";
/** Where the catalog is published (strategy §4.2). */
export declare const CATALOG_ID = "https://ds.bradfrost.com/catalog/eddie/v1";
export declare const CATALOG_PROTOCOL_VERSION = "1.0";
/** The ASCII subset of a UAX #31 identifier — every node, prop, slot and extension key must match. */
export declare const IDENTIFIER_RE: RegExp;
/** Longest description carried per node or prop; the full text stays in `eddie_get_component`. */
export declare const DESCRIPTION_MAX = 240;
/** Minimal JSON Schema surface this builder emits. */
export interface JsonSchema {
    type?: string | string[];
    const?: unknown;
    enum?: unknown[];
    default?: unknown;
    description?: string;
    items?: JsonSchema;
    properties?: Record<string, JsonSchema>;
    required?: string[];
    additionalProperties?: boolean;
    $ref?: string;
    $comment?: string;
}
/** Everything the catalog knows about a node beyond its JSON Schema. Keys are UAX #31 identifiers. */
export interface EddieExtensions {
    /** The Eddie custom-element tag this node renders as, or the root tag of a composition's expansion. */
    eddie_tag: string;
    /** `primitive` maps 1:1 to a tag; `composition` expands into several (strategy §4.2); `text` is the built-in text node. */
    eddie_kind: 'primitive' | 'composition' | 'text';
    eddie_package?: string;
    eddie_atomicLevel?: string;
    eddie_category?: string;
    eddie_projectScope?: string;
    eddie_recipeKind?: string;
    /** The `<script>` tag(s) a no-build page needs for this node, from the graph's `runtime.scriptTag`. */
    eddie_scriptTag?: string;
    /** Catalog `slots.<key>` → the real `slot="…"` attribute value (keys are identifiers; slot attrs may carry hyphens). */
    eddie_slotAttrs?: Record<string, string>;
    /** Tags the graph says this component composes with. */
    eddie_composesWith?: string[];
    /** Composition nodes only: the Eddie markup skeleton the renderer expands the node into. */
    eddie_expansion?: string;
    /** Composition nodes only: every tag the expansion may emit. */
    eddie_tags?: string[];
    /** Asks this node should resolve to (`@useWhen`, or a profile's authored criteria). #1888 */
    eddie_useWhen?: string[];
    /** Similar asks that belong elsewhere, naming the alternative (`@notWhen`). #1888 */
    eddie_notWhen?: string[];
    /** Where the full documentation for this node lives. */
    eddie_docs: string;
}
/** One `components.<Name>` entry: a JSON Schema plus the v1.0 composition fields. */
export interface CatalogComponent extends JsonSchema {
    allowedParents?: string[];
    allowedChildren?: string[];
    metadata: {
        extensions: EddieExtensions;
    };
}
/** The catalog document. */
export interface Catalog {
    $schema: string;
    $id: string;
    catalogId: string;
    protocolVersion: string;
    title: string;
    description: string;
    /** Eddie-level: which profile produced this document. */
    profile: string;
    /** Eddie-level: false until every container declares `allowedChildren` and every composition declares regions (#1685, #1686). */
    contractComplete: boolean;
    /** Eddie-level: the Eddie release the graph was built from. */
    eddieVersion: string;
    instructions: string;
    components: Record<string, CatalogComponent>;
    functions: Record<string, never>;
    /** Eddie-level: the graph's anti-patterns this profile can express, for `validateSpec` (#1898). */
    antiPatterns: AntiPattern[];
}
/** A composition node authored by a profile: one name that expands into several Eddie tags. */
export interface CompositionNodeSpec {
    name: string;
    description: string;
    /** Tags of the nodes allowed inside; resolved to catalog names at build time. */
    allowedChildrenTags: string[];
    /** Extra JSON Schema props beyond `component` and `children`. */
    properties?: Record<string, JsonSchema>;
    /** The Eddie markup skeleton the renderer expands this node into. */
    expansion: string;
    /** Every tag the expansion may emit. Must exist in the graph. */
    tags: string[];
    /** Asks this shape should resolve to (#1888). */
    useWhen?: string[];
    /** Similar asks that belong to another shape, naming it (#1888). */
    notWhen?: string[];
}
/** A named subset of the graph plus optional composition nodes and instructions. */
export interface CatalogProfile {
    name: string;
    title: string;
    description: string;
    /** Which graph entries this profile includes. */
    include: (entry: ComponentEntry) => boolean;
    compositions?: CompositionNodeSpec[];
    instructions: string;
}
/**
 * The catalog name for a graph entry.
 *
 *   ed-button            → Button
 *   ed-r-stat-card       → StatCard
 *   ed-p-app-dashboard   → AppDashboardTemplate   (pages are reference templates)
 *
 * Pages take a `Template` suffix so they never collide with a profile's
 * composition nodes (`FormPage` vs `ed-p-form`) and so the name says what the
 * graph says: "fork this file", not "instantiate this".
 */
export declare function identifierFor(entry: Pick<ComponentEntry, 'tagName' | 'atomicLevel'>): string;
/**
 * Assign a unique catalog name to every included entry.
 *
 * `identifierFor` alone collides twice in today's graph: `ed-search-form`
 * (core, deprecated) vs `ed-r-search-form`, and `ed-timeline-node` vs
 * `ed-r-timeline-node`. The rule is deterministic and narrow: when a core
 * component and a recipe derive the same name, the recipe takes a `Recipe`
 * suffix (`SearchFormRecipe`). Any other collision — two recipes, a recipe
 * and a page — is a build failure, because a renderer cannot resolve it and
 * a silent rename would move a name out from under a consumer.
 */
export declare function assignNames(entries: ComponentEntry[]): {
    nameByTag: Map<string, string>;
    tagByName: Map<string, string>;
};
/** Truncate a description to one sentence-ish chunk under `DESCRIPTION_MAX`. */
export declare function shortDescription(text: string | undefined): string;
/**
 * JSON Schema for one graph property, or `null` when the prop cannot be set
 * from JSON (function-typed callbacks, render hooks).
 */
export declare function propertySchema(prop: PropertyEntry): JsonSchema | null;
/**
 * Split a graph entry's slots into the A2UI `children` list (the default
 * slot) and a `slots` object (named slots, keyed by identifier).
 */
export declare function slotSchemas(slots: SlotEntry[]): {
    children?: JsonSchema;
    slots?: JsonSchema;
    slotAttrs: Record<string, string>;
};
/** One primitive node: a graph entry as a catalog component. */
export declare function primitiveNode(entry: ComponentEntry): CatalogComponent;
/** One composition node from a profile spec, with its tags resolved to catalog names. */
export declare function compositionNode(spec: CompositionNodeSpec, nameForTag: (tag: string) => string | undefined): CatalogComponent;
/**
 * The generated "Anti-patterns" section of a profile's `instructions` (#1888):
 * every graph anti-pattern whose tags are all in the profile, written in
 * catalog-node names (the vocabulary the model composes in) with the Eddie
 * selector alongside. Replaces the hand-written duplicates that used to live
 * in `profiles.ts`.
 */
export declare function antiPatternInstructions(patterns: AntiPattern[], nameByTag: Map<string, string>): string;
export interface BuildCatalogOptions {
    /** The Eddie release the graph was built from (`EDDIE_BRAIN_VERSION`). */
    eddieVersion: string;
    /** Where this profile's document is published; becomes `$id`. */
    publishedUrl?: string;
    /** The graph's anti-patterns (#1888); those the profile can express become an `instructions` section. */
    antiPatterns?: AntiPattern[];
}
/**
 * Build one profile's catalog from the graph's component entries.
 *
 * Throws on a name collision (two tags deriving the same identifier) and on a
 * composition node that references a tag outside the profile — both are
 * build failures, not warnings, because a renderer cannot resolve them.
 */
export declare function buildCatalog(entries: ComponentEntry[], profile: CatalogProfile, options: BuildCatalogOptions): Catalog;
//# sourceMappingURL=build-catalog.d.ts.map