import { E as EvalContext } from './remote-B5coCv6B.js';
export { C as ComponentLoader, R as Registry, a as RegistryEntry, b as RemoteFetchOptions, c as clearRemoteSchemaCache, d as createRegistry, e as evaluateCondition, f as evaluateProps, g as fetchRemoteSchema, l as lookupPath, r as resolveValue } from './remote-B5coCv6B.js';
import { P as PageSchema, S as SchemaPatch, R as RendererDiagnostic, V as VariantList, A as ActionExpr, C as ComponentSchema } from './schema-C4Hcw2Y6.js';
export { a as ConditionExpr, b as SchemaPatchOp, c as SchemaPatchTarget, d as ValueExpr, e as VariantEntry } from './schema-C4Hcw2Y6.js';

type Diag = (d: RendererDiagnostic) => void;
/**
 * Apply a list of patches in order to a base schema, producing a new schema.
 * Does not mutate the input. Unknown targets produce diagnostics rather than
 * throwing, so remote payloads that drift out of sync degrade gracefully.
 */
declare function mergeSchema(base: PageSchema, patches: SchemaPatch[] | undefined, onDiagnostic?: Diag): PageSchema;

interface ResolvedVariant {
    base: PageSchema;
    patches: SchemaPatch[];
    /** Which entry index won; useful for debugging. */
    entryIndex: number;
}
declare function defineVariants(list: VariantList): VariantList;
/**
 * Pick the first matching variant entry.
 *
 * Matching rules:
 * - Entries with a `when` expression match iff it evaluates truthy.
 * - An entry without `when` always matches (typically the fallback tail).
 *
 * If no entry matches, returns null and the caller should fall back to its
 * own default base schema (typical case: the renderer caller passes a base
 * schema independently).
 */
declare function resolveVariant(variants: VariantList, ctx: EvalContext, onDiagnostic?: (d: RendererDiagnostic) => void): ResolvedVariant | null;

/**
 * A unit of rendering work, framework-agnostic. Each visible component becomes
 * one or more `RenderNode` instances (multiple when `for` expansion is used).
 */
interface RenderNode {
    name: string;
    /** Stable-ish key; the walker composes ids, loop indices, etc. */
    key: string;
    /** Evaluated props (after `evaluateProps`). */
    props: Record<string, unknown>;
    /** Children in default slot. */
    children: RenderNode[];
    /** Named slots. */
    slots: Record<string, RenderNode[]>;
    /** Event handler bindings (raw action expressions; framework wrapper dispatches). */
    events: Record<string, ActionExpr>;
    /** Original schema for consumers that need deeper introspection. */
    source: ComponentSchema;
}
/**
 * Turn a schema's `components` list into a list of render-ready nodes.
 *
 * Applies: `when` (visibility), `for` (expansion), `props` evaluation, and
 * recursion through children and slots. Event wiring is left to the framework
 * binding so that Vue/React can build their native handler shape.
 */
declare function walkComponents(list: ComponentSchema[] | undefined, ctx: EvalContext, keyPrefix?: string): RenderNode[];
/**
 * Helper: dispatch an action (or action list) by looking the type up in a map.
 * Vue/React bindings call this on each bound event.
 */
declare function dispatchAction(expr: ActionExpr, actions: Record<string, (payload: Record<string, unknown>, ctx: EvalContext) => void>, ctx: EvalContext): void;

export { ActionExpr, ComponentSchema, EvalContext, PageSchema, type RenderNode, RendererDiagnostic, type ResolvedVariant, SchemaPatch, VariantList, defineVariants, dispatchAction, mergeSchema, resolveVariant, walkComponents };