/**
 * KoraElement — the vanilla custom-element base for the Kora / Ada Handle component library.
 *
 * NO FRAMEWORK. Reactivity is assembled from native platform primitives only:
 *
 *   1. Proxy + Reflect wrap `state`, so ordinary mutation (`this.state.x = 1`) is observable.
 *      The `set`/`deleteProperty` traps forward the real operation via Reflect (preserving
 *      correct receiver semantics) and then schedule a render.
 *   2. A `<template>`-derived light-DOM tree whose dynamic nodes are captured once as refs in
 *      hydrate(); update() writes to those refs directly. No diffing engine, no re-parse.
 *
 * LIGHT DOM by default (renderRoot === this) so server-rendered HTML hydrates trivially, host
 * CSS / design tokens apply without piercing a shadow boundary, forms participate natively, and
 * ARIA IDREF associations are not severed. Shadow DOM is reserved for client-only widgets that
 * subclass and override `renderRoot`.
 *
 * SSR CONTRACT: attributes are the single source of truth. The server renders inner markup that
 * matches what template() + update() would produce for those same attributes, and tags the host
 * with the SSR marker attribute. On the client the element ADOPTS that markup (wires refs, runs
 * one idempotent update()) instead of re-rendering — so there is no flicker and no clobbering.
 * An element created client-side (no marker) renders fresh from template().
 */
/** Host attribute the server sets to signal "I already rendered this element's children." */
export declare const SSR_MARKER = "data-kora-ssr";
export declare abstract class KoraElement<S extends object = Record<string, unknown>> extends HTMLElement {
    #private;
    protected readonly state: S;
    constructor();
    /** Reactive state shape + defaults. Override to declare fields. */
    protected initialState(): S;
    /** Inner HTML for a fresh (client-side) first render. Must match what the SSR
     *  renderer emits for equivalent attributes so adoption is seamless. */
    protected abstract template(): string;
    /** Capture node refs and attach event listeners once, against whichever DOM exists
     *  (freshly rendered OR adopted from SSR). */
    protected hydrate(): void;
    /** Apply current state to the DOM through captured refs. MUST be idempotent and MUST
     *  mutate existing nodes (never replace them) so SSR adoption stays seamless. */
    protected update(): void;
    /** Render target. Light DOM by default; a client-only widget may override to a shadow root. */
    protected get renderRoot(): Element | ShadowRoot;
    /** Override to true for composition components that host app-provided children. When set,
     *  authored children are captured before the fresh render and re-projected into the template's
     *  mount points: an element with `slot="x"` goes to `[data-kora-slot="x"]`, everything else to
     *  `[data-kora-content]`. (On SSR adoption the server already placed them, so we skip this.) */
    protected get preservesChildren(): boolean;
    connectedCallback(): void;
    disconnectedCallback(): void;
    /** Default attribute→state bridge: mirrors the raw attribute value into state under a
     *  camelCased key. Override for typed parsing (booleans, numbers, enums). */
    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
}
//# sourceMappingURL=kora-element.d.ts.map