/**
 * emit-typed-native-rust.ts — Rust COMBINED read emitter (bc#77/#94, the 1.0 read de-box; STRUCT-ONLY,
 * FULLY-CONCRETE). The Rust twin of emit-typed-native-go.ts, now concretized to match the Go contract.
 *
 * # The op-agnostic leaf transport contract (mirrors Go)
 *
 * A covered read no longer crosses a generic `Value`/`RawValue` enum on the PORT or RESULT plane, and it no
 * longer routes through a per-node handler trait. At each covered node's execution point the runner calls
 * the op-agnostic leaf TRANSPORT symbol DIRECTLY — the resolved `leaf_<comp>` (or a consumer override) with
 * the node's port fields SPREAD:
 *
 *   leaf_<comp>(ports.f_a, &ports.f_b, …) -> Result<Wire, BehaviorError>
 *
 * The transport takes the node's CONCRETE native port values (typed, direct — no `PortReaderT`, no by-name
 * `port()`, Copy→move / non-Copy→borrow) and returns the node's result WIRE (a value implementing
 * WireValue — the producer's datum at the result-consumption point). A failure is the Result's Err arm, a
 * concrete BehaviorError carrying the leaf's structured Error Value. A leaf is ONE transport, not one method
 * per authored node (litedbmodel = a single `execute_sql`; graphddb = `get_item` / `query` /
 * `batch_get_item`), so consumer transport code is a fixed set of ops. The covered entry (#192: the
 * authored method name, positional params — the `InNR<Comp>` box removed)
 *   <method>(<positional params>) -> Result<T, …>
 * de-boxes each result wire INLINE — the ONE SSoT walk (emit-shared-debox.ts `buildDeBoxPlan`) folded into
 * fully-unrolled probe/match Rust at each node's consumption point (NO `decode_wire_*` helper, NO
 * output-side recursion): a nested record expands to a nested struct literal, a collection to a nested
 * loop. NO `RawValue`, NO `Value::`-enum crossing, NO `match` on a generic value on the covered plane. The
 * wire's concrete type is inferred from the transport's return type (no annotation).
 *
 * A covered read also takes a per-component CONCRETE input struct `InNR<Comp>` (fields = inputPorts with
 * their declared Rust types) instead of a `&[(String, Value)]`. A simple string/scalar port — a literal,
 * a ref to a typed input field (`in_.user_id`), a ref to a prior node's typed struct scalar, or a concat
 * of statically-string parts — lowers DIRECTLY to a native Rust expression
 * (`format!("USER#{}", in_.user_id)`) assigned straight into the concrete ports-struct field: NO Value,
 * NO `match`, NO type-assert. A port that CANNOT be statically proven the concrete type (a dynamic
 * operator, a refOpt/opt field, or a Value-typed port) falls back to the Value path (documented — the
 * only place a `Value`/`match` could survive; the covered string key/table/projection ports never hit it).
 *
 * INLINE sequential exec (no run_plan): node results are typed struct cells; a relation child reads the
 * parent's REAL struct result via direct field access, and the child-present decision (bindField null /
 * continue skip) is made from the real parent value — so relation / connection converge with
 * run_behavior (fixes #323/#74). map/parallel arms de-box each per-element wire inline into the element.
 *
 * The generic `RawValue`/`PortReaderT`/`NativeRawComponentExec` seam (rust/src/rawabi.rs) is RETAINED for
 * the uncovered/interpreted fallback — the covered concrete path does not touch it.
 *
 * Scope: fully-typed sequential componentRef reads with STATIC ports (literal / ref / concat) and a
 * native-lowerable output. An untyped covered SHAPE fails closed (no silent re-box). cond is not covered.
 */
import type { EmitterPlugin } from "./core.js";
/**
 * rustSharedWireTypesModule (#165, rust twin of goSharedWireTypesPackage) — the BC-GENERATED shared module
 * content emitted when the covered module is generated with --shared-types-import. Carries the SAME wire seam
 * the covered module emits in-crate when the flag is absent (Probe + WireValue/WireRow/WireList +
 * the probe classifiers) so a separate leaf-transport crate can take a `WireRow` payload + build+return
 * `WireValue` (and the covered module reference them) without an import cycle. #183: the transport ABI is the
 * generic `WireRow` payload built inline at the call site — there are NO per-node/per-role batch ports structs
 * to emit here. The wire types derive Clone (a cross-crate transport + the #164 passthrough store clone them).
 * Self-contained + runtime-free — drop it in the shared crate's lib.rs (a separate crate) or a module. */
export declare function rustSharedWireTypesModule(): string;
export declare const rustTypedNativeEmitter: EmitterPlugin;
//# sourceMappingURL=emit-typed-native-rust.d.ts.map