/**
 * SpecVerse Convention Processor
 *
 * Processes YAML + conventions into structured AST
 * Handles v3.1 container format with namespaces and "name: Type modifiers" patterns
 *
 * Convention processors are discovered from entity modules via the entity registry.
 * Each entity module provides its own processor; this class orchestrates them.
 */
import { SpecVerseAST } from './types/ast.js';
import { ProcessorContext } from '@specverse/types';
export declare class ConventionProcessor implements ProcessorContext {
    warnings: string[];
    /** Hard errors collected during processing. The parser rolls these up
     * into the parseResult.errors so callers (e.g. app-demo's spec-loader)
     * can refuse to load specs with broken constraints. */
    errors: string[];
    private entityProcessors;
    private behaviouralProcessor;
    private componentEntityTypes;
    constructor();
    /**
     * Get accumulated warnings
     */
    getWarnings(): string[];
    /**
     * Get accumulated hard errors. Spec consumers should treat a non-empty
     * list as a load-blocker (refuse to start the spec server).
     */
    getErrors(): string[];
    /**
     * Clear accumulated warnings + errors.
     */
    clearWarnings(): void;
    /**
     * Add a warning
     */
    addWarning(message: string): void;
    /**
     * Main processing entry point for v3.1 container format
     */
    process(yamlData: any): SpecVerseAST;
    /**
     * Process a single component
     */
    private processComponent;
    /**
     * Phase 2 — expand a model's `constraints:` array (author form) plus any
     * `transitions.condition` aliases into the typed `ModelConstraintSpec[]`
     * the rest of the pipeline consumes.
     *
     * - `requires:` strings, arrays, and `{and|or|not}` trees are walked
     *   recursively; each leaf is expanded via BehaviouralConventionProcessor
     *   with the owning model as `currentModel`. Sub-expressions are joined
     *   with Quint `and`/`or`/`not` to produce ONE compound guard per record.
     * - `transitions.condition` from structured lifecycles is auto-mapped to
     *   `{on: 'evolve.<transition>', requires: condition}` — author can write
     *   either form, never both for the same transition (current pipeline
     *   warns rather than errors; tightening to a parse-time conflict error
     *   is a follow-up).
     * - Leaves that don't match any convention emit a parser warning and skip
     *   the affected record; remaining records still produce guards.
     */
    private expandModelConstraints;
    /**
     * Expand one `{on, requires}` record into a ModelConstraintSpec.
     *
     * `origin` distinguishes author-written records ('authored') from records
     * synthesised from `transitions.condition` ('transition-alias'). The
     * distinction is preserved in `requires.source.convention` so the
     * AST → YAML round-trip only emits author records back as `model.constraints`
     * (aliased ones still live in `lifecycles.*.transitions.<action>` as
     * `when=` clauses — emitting them in both places would double-validate).
     */
    private expandConstraintRecord;
    /**
     * Recursively expand a `requires:` tree into a single Quint expression.
     * Returns null if any leaf fails to match a convention.
     */
    private expandRequiresTree;
    /**
     * Process a single manifest
     */
    private processManifest;
    /**
     * Process types section with convention expansion
     * "ProductCode: String pattern='^[A-Z]{3}-\\d{4}$'" -> Full type model
     */
    private processPrimitives;
    /**
     * Parse type convention string
     * "String pattern='^[A-Z]{3}-\\d{4}$' required description='Product code'"
     */
    private parsePrimitiveConvention;
    /**
     * Smart split that respects brackets and quotes
     * "String values=['a', 'b', 'c'] required" -> ["String", "values=['a', 'b', 'c']", "required"]
     */
    private smartSplit;
    /**
     * Parse quoted value from modifier: pattern="value" -> "value"
     */
    private parseQuotedValue;
    /**
     * Parse array value from modifier: values=["a","b","c"] -> ["a","b","c"]
     */
    private parseArrayValue;
}
//# sourceMappingURL=convention-processor.d.ts.map