/**
 * `mergeRootProps(internal, user)` — public slot-function prop merger.
 *
 * Distinct from `mergePropsN` (used by ~20 React-port primitives). This
 * one is for the Solid 2.0-native compound surface where a primitive
 * exposes `c.trigger()` / `c.root()` slot functions and the consumer
 * spreads them onto an element with `<Tag {...c.trigger()} />`.
 *
 * Per-key resolution:
 * - `on*` handlers: internal runs first, user runs after unless the
 *   event was `preventDefault()`-ed by internal. `user[k] === undefined`
 *   does NOT clear internal — it's treated as "absent". This is the key
 *   difference from Solid's `merge` (RFC 04) and what stops consumers
 *   accidentally killing library behaviour by spreading
 *   `{ onClick: undefined }`.
 * - `class`: returns `[internal.class, user.class]` per RFC 07 — Solid's
 *   class binding handles nested clsx shapes per entry. No string concat.
 * - `style`: object declarations merge with user values winning. Mixed
 *   object/string values serialize deterministically with internal
 *   declarations first and user declarations second.
 * - `ref`: array form `[internal.ref, user.ref]` (skip absent sides;
 *   single value if only one side present). Solid's `applyRef` flattens.
 * - everything else (`data-*`, `aria-*`, plain attrs): user wins when
 *   defined, internal provides the reactive default. `user[k] ===
 *   undefined` means internal wins.
 *
 * Reactivity: getters delegate reads back to `internal[k]` / `user[k]` so
 * source-side getters (e.g. `get "data-state"() { return open() ? ... }`)
 * stay live across spreads. The output is a plain object — Solid's
 * compiled spread iterates `Object.keys` once at first spread and binds a
 * render effect per key; each binding then reads through the getter on
 * every relevant flush.
 *
 * Implementation: pre-bake a getter per key in `keys(internal) ∪ keys(user)`
 * at call time. Specialised per which side(s) declared the key — the
 * cheap path (internal-only key) skips per-access branching. Faster than
 * the prior Proxy form (~2.4× by microbench: 123ms → 51ms for 7M reads)
 * and produces an indistinguishable shape for downstream consumers
 * (`Object.keys`, `Object.getOwnPropertyDescriptor`, `in` for known keys
 * all match).
 *
 * Slot prop bags have a static key set at the call site, so pre-baking
 * is correct. Dynamic key sets that grow over time still need `mergePropsN`.
 */
import type { ElementStyle } from "./types.js";
/**
 * Merge two Solid-native style values with the later value taking precedence.
 * Object/object inputs remain objects. If either side is serialized CSS, the
 * result is serialized with internal declarations first and user declarations
 * second, which is deterministic across browser and server rendering.
 */
export declare function mergeElementStyles(internal: ElementStyle, user: ElementStyle): ElementStyle;
/**
 * Accepts any two prop bags and returns the merged bag as a plain
 * `Record<string, unknown>` — which is all every call site needs (each one
 * either assigns the result to a `Record<string, unknown>` or spreads it onto
 * a `dynamic()` element). The widening cast lives HERE, once, instead of forcing every
 * call site to write `internal` just to
 * satisfy a generic whose precise return type nothing consumes.
 */
export declare function mergeRootProps(internal: object, user?: object): Record<string, unknown>;
//# sourceMappingURL=merge-root-props.d.ts.map