import { type MetaData } from "@metaobjectsdev/metadata";
import type { RenderContext } from "../render-context.js";
/** The extracted-mirror interface name for a value-object (`<Name>Extracted`). ADR-0044/#228:
 *  `ctx` (optional) resolves the collision-scoped entity-domain emitted name (Task 3's
 *  `valueObjectEmittedName`), so a cross-package short-name collision qualifies both the
 *  entity module AND its extract mirror identically (`AcmeAlphaNoteExtracted`). Omitted →
 *  the bare `vo.name` (bare template unit-test calls; byte-identical to pre-#228 output). */
export declare function mirrorName(vo: MetaData, ctx?: RenderContext): string;
/**
 * Emit the nested-aware mirror interface for `vo` and every value-object reachable from it
 * (deduped by simple name; cycle-safe). The payload mirror keeps the canonical `<Payload>Extracted`
 * name (passed in) so the existing self-contained extract<Name>() and the delegating overload
 * share one mirror type. Returns the joined interface declarations in stable (BFS) order.
 */
export declare function nestedMirrorInterfaces(vo: MetaData, root: MetaData, payloadMirror: string, ctx?: RenderContext): string;
/**
 * Emit one `from<VO>Extracted(o)` mapper per value-object reachable from `vo` (payload + nested,
 * deduped). Each mapper reads the assembled object via readProp() and recurses into nested
 * mappers for object/array-of-object components. Nested mappers use `from<NestedName>Extracted`
 * returning `<NestedName>Extracted`. The ROOT mapper is overridden to the template-derived names
 * (`rootMapperFn` / `rootMirror`) so it matches the canonically-named root mirror interface — the
 * payload VO's own name may differ from the template name.
 */
export declare function nestedMappers(vo: MetaData, root: MetaData, rootMapperFn: string, rootMirror: string, ctx?: RenderContext): string;
/** The root mapper's name + mirror — derived from the template, not the payload VO. */
export declare function rootMapperName(template: string): string;
/**
 * The set of generated-helper names the mappers for `vo` (+ reachable nested VOs) actually
 * reference. Used to emit only the needed helpers (consumer projects may run noUnusedLocals).
 * `readProp` + at least one dlg* reader are always present once any mapper is emitted.
 */
export declare function usedHelpers(vo: MetaData, root: MetaData): Set<string>;
/** True iff the payload (or any reachable nested VO) has a nested-object / array-of-object field. */
export declare function hasNested(vo: MetaData, root: MetaData): boolean;
/**
 * The shared runtime-side helper block the generated mappers rely on:
 *   • readProp  — null-tolerant read mirroring the MetaField getValue SPI (ValueObject.get(name)
 *                 else plain-property access); keeps the mappers reflection-free + backing-agnostic.
 *   • mapObjectList — map each element of an assembled array via a per-element mapper.
 *   • dlg* readers — light null-tolerant coercion to the mirror's nullable scalar shapes. The
 *     `dlg` prefix avoids shadowing the render ExtractMap helpers (`asString(d, key)` etc.) that
 *     the self-contained extract path imports into the SAME file — a collision would silently
 *     rebind those two-arg map readers to these one-arg readers.
 * Emitted once per parser file.
 */
export declare function delegateHelpers(used: Set<string>): string;
//# sourceMappingURL=extract-delegate-emitter.d.ts.map