interface KindergardenGroupListener {
    addNode(node: Node): any;
    removeNode(node: Node): any;
}
declare class KindergartenGroup {
    private kindergarten;
    private groupListener;
    children: Set<Node>;
    constructor(kindergarten: Kindergarten);
    addListener(groupListener: KindergardenGroupListener): void;
    ensureNode(node: Node, atIndex?: number): void;
    removeNode(node: Node): void;
    removeNodeAt(pos: number): void;
    moveNode(from: number, to: number): void;
}
declare class Kindergarten {
    readonly parentNode: Element;
    private groups;
    constructor(parentNode: Element);
    newGroup(): KindergartenGroup;
    getGroups(): ReadonlyArray<KindergartenGroup>;
    getOffsetFor(group: KindergartenGroup): number;
}

interface updateFunc<T> {
    (newData: T): void;
    _origUpdates?: Array<updateFunc<T>>;
}
type MountFunc = () => void;
declare const noop: () => void;
declare const noopUpdate: updateFunc<any>;
declare const noopMount: MountFunc;
interface BaseJayElement<ViewState> {
    update: updateFunc<ViewState>;
    mount: MountFunc;
    unmount: MountFunc;
}
interface JayElement<ViewState, Refs> extends BaseJayElement<ViewState> {
    refs: Refs;
}
type Coordinate = string[];
interface JayEvent<EventType, ViewState> {
    event: EventType;
    viewState: ViewState;
    coordinate: Coordinate;
}
type JayEventHandler<EventType, ViewState, Returns> = (event: JayEvent<EventType, ViewState>) => Returns;
/** Event type for ViewState change notifications */
declare const VIEW_STATE_CHANGE_EVENT = "viewStateChange";
interface JayComponent<Props, ViewState, jayElement extends BaseJayElement<ViewState>> {
    element: jayElement;
    update: updateFunc<Props>;
    mount: MountFunc;
    unmount: MountFunc;
    addEventListener: (type: string, handler: JayEventHandler<any, ViewState, void>) => void;
    removeEventListener: (type: string, handler: JayEventHandler<any, ViewState, void>) => void;
    /** Current ViewState (read-only, available when using @jay-framework/component) */
    readonly viewState?: ViewState;
}
type PropsFrom<Type> = Type extends JayComponent<infer Props, any, any> ? Props : null;
type ViewStateFrom<Type> = Type extends JayComponent<any, infer ViewState, any> ? ViewState : null;
type ElementFrom<Type> = Type extends JayComponent<any, any, infer Element> ? Element : null;
type JayComponentConstructor<Props> = (props: Props) => JayComponent<Props, any, any>;
type PreRenderElement<ViewState extends object, Refs extends object, JayElementT extends JayElement<ViewState, Refs>> = (options?: RenderElementOptions) => [Refs, RenderElement<ViewState, Refs, JayElementT>];
type RenderElement<ViewState extends object, Refs extends object, JayElementT extends JayElement<ViewState, Refs>> = (vs: ViewState) => JayElementT;
interface RenderElementOptions {
    eventWrapper?: JayEventHandlerWrapper<any, any, any>;
    sanitizeHtml?: (html: string) => string;
}
type JayEventHandlerWrapper<EventType, ViewState, Returns> = (orig: JayEventHandler<EventType, ViewState, Returns>, event: JayEvent<EventType, ViewState>) => Returns;
interface ContextMarker<ContextType> {
}
declare const _jayContractBrand: unique symbol;
type JayContract<ViewState extends object, Refs extends object, SlowViewState extends object = never, FastViewState extends object = never, InteractiveViewState extends object = never, Props extends object = {}> = {
    readonly [_jayContractBrand]: {
        viewState: ViewState;
        refs: Refs;
        slowViewState: SlowViewState;
        fastViewState: FastViewState;
        interactiveViewState: InteractiveViewState;
        props: Props;
    };
};
type ExtractViewState<A> = A extends JayContract<infer ViewState, any, any, any, any, any> ? ViewState : never;
type ExtractRefs<A> = A extends JayContract<any, infer Refs, any, any, any, any> ? Refs : never;
type ExtractSlowViewState<A> = A extends JayContract<any, any, infer SlowViewState, any, any, any> ? SlowViewState : never;
type ExtractFastViewState<A> = A extends JayContract<any, any, any, infer FastViewState, any, any> ? FastViewState : never;
type ExtractInteractiveViewState<A> = A extends JayContract<any, any, any, any, infer InteractiveViewState, any> ? InteractiveViewState : never;
type ExtractProps<A> = A extends JayContract<any, any, any, any, any, infer Props> ? Props : never;
declare enum LogType {
    ASYNC_ERROR = 0,
    CONTEXT_NOT_FOUND = 1
}
type JayLog = {
    log: (type: LogType) => void;
    error: (type: LogType, error: Error) => void;
};
declare const jayLog: JayLog;

declare module '@jay-framework/runtime' {
    interface BaseJayElement<ViewState> {
        dom: Element;
    }
}

/** DOM element references **/
type JayNativeFunction<ElementType extends HTMLElement, ViewState, Result> = (elem: ElementType, viewState: ViewState) => Result;
interface JayNativeEventBuilder<ViewState, EventData> {
    then(handler: (event: JayEvent<EventData, ViewState>) => void): void;
}
interface GlobalJayEvents<ViewState> {
    onabort(handler: JayEventHandler<UIEvent, ViewState, void>): void;
    onabort$<EventData>(handler: JayEventHandler<UIEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onanimationcancel(handler: JayEventHandler<AnimationEvent, ViewState, void>): void;
    onanimationcancel$<EventData>(handler: JayEventHandler<AnimationEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onanimationend(handler: JayEventHandler<AnimationEvent, ViewState, void>): void;
    onanimationend$<EventData>(handler: JayEventHandler<AnimationEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onanimationiteration(handler: JayEventHandler<AnimationEvent, ViewState, void>): void;
    onanimationiteration$<EventData>(handler: JayEventHandler<AnimationEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onanimationstart(handler: JayEventHandler<AnimationEvent, ViewState, void>): void;
    onanimationstart$<EventData>(handler: JayEventHandler<AnimationEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onauxclick(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onauxclick$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onblur(handler: JayEventHandler<FocusEvent, ViewState, void>): void;
    onblur$<EventData>(handler: JayEventHandler<FocusEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oncanplay(handler: JayEventHandler<Event, ViewState, void>): void;
    oncanplay$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oncanplaythrough(handler: JayEventHandler<Event, ViewState, void>): void;
    oncanplaythrough$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onchange(handler: JayEventHandler<Event, ViewState, void>): void;
    onchange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onclick(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onclick$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onclose(handler: JayEventHandler<Event, ViewState, void>): void;
    onclose$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oncontextmenu(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    oncontextmenu$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oncuechange(handler: JayEventHandler<Event, ViewState, void>): void;
    oncuechange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondblclick(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    ondblclick$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondrag(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondrag$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondragend(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondragend$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondragenter(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondragenter$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondragleave(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondragleave$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondragover(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondragover$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondragstart(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondragstart$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondrop(handler: JayEventHandler<DragEvent, ViewState, void>): void;
    ondrop$<EventData>(handler: JayEventHandler<DragEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ondurationchange(handler: JayEventHandler<Event, ViewState, void>): void;
    ondurationchange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onemptied(handler: JayEventHandler<Event, ViewState, void>): void;
    onemptied$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onended(handler: JayEventHandler<Event, ViewState, void>): void;
    onended$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onfocus(handler: JayEventHandler<FocusEvent, ViewState, void>): void;
    onfocus$<EventData>(handler: JayEventHandler<FocusEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onformdata(handler: JayEventHandler<void, ViewState, void>): void;
    onformdata$<EventData>(handler: JayEventHandler<any, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ongotpointercapture(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    ongotpointercapture$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oninput(handler: JayEventHandler<Event, ViewState, void>): void;
    oninput$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    oninvalid(handler: JayEventHandler<Event, ViewState, void>): void;
    oninvalid$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onkeydown(handler: JayEventHandler<KeyboardEvent, ViewState, void>): void;
    onkeydown$<EventData>(handler: JayEventHandler<KeyboardEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onkeypress(handler: JayEventHandler<KeyboardEvent, ViewState, void>): void;
    onkeypress$<EventData>(handler: JayEventHandler<KeyboardEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onkeyup(handler: JayEventHandler<KeyboardEvent, ViewState, void>): void;
    onkeyup$<EventData>(handler: JayEventHandler<KeyboardEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onload(handler: JayEventHandler<Event, ViewState, void>): void;
    onload$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onloadeddata(handler: JayEventHandler<Event, ViewState, void>): void;
    onloadeddata$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onloadedmetadata(handler: JayEventHandler<Event, ViewState, void>): void;
    onloadedmetadata$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onloadstart(handler: JayEventHandler<Event, ViewState, void>): void;
    onloadstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onlostpointercapture(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onlostpointercapture$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmousedown(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmousedown$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmouseenter(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmouseenter$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmouseleave(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmouseleave$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmousemove(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmousemove$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmouseout(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmouseout$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmouseover(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmouseover$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onmouseup(handler: JayEventHandler<MouseEvent, ViewState, void>): void;
    onmouseup$<EventData>(handler: JayEventHandler<MouseEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpause(handler: JayEventHandler<Event, ViewState, void>): void;
    onpause$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onplay(handler: JayEventHandler<Event, ViewState, void>): void;
    onplay$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onplaying(handler: JayEventHandler<Event, ViewState, void>): void;
    onplaying$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointercancel(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointercancel$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerdown(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerdown$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerenter(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerenter$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerleave(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerleave$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointermove(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointermove$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerout(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerout$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerover(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerover$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onpointerup(handler: JayEventHandler<PointerEvent, ViewState, void>): void;
    onpointerup$<EventData>(handler: JayEventHandler<PointerEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onprogress(handler: JayEventHandler<ProgressEvent, ViewState, void>): void;
    onprogress$<EventData>(handler: JayEventHandler<ProgressEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onratechange(handler: JayEventHandler<Event, ViewState, void>): void;
    onratechange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onreset(handler: JayEventHandler<Event, ViewState, void>): void;
    onreset$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onresize(handler: JayEventHandler<UIEvent, ViewState, void>): void;
    onresize$<EventData>(handler: JayEventHandler<UIEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onscroll(handler: JayEventHandler<Event, ViewState, void>): void;
    onscroll$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onseeked(handler: JayEventHandler<Event, ViewState, void>): void;
    onseeked$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onseeking(handler: JayEventHandler<Event, ViewState, void>): void;
    onseeking$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onselect(handler: JayEventHandler<Event, ViewState, void>): void;
    onselect$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onselectionchange(handler: JayEventHandler<Event, ViewState, void>): void;
    onselectionchange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onselectstart(handler: JayEventHandler<Event, ViewState, void>): void;
    onselectstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onstalled(handler: JayEventHandler<Event, ViewState, void>): void;
    onstalled$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onsubmit(handler: JayEventHandler<Event, ViewState, void>): void;
    onsubmit$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onsuspend(handler: JayEventHandler<Event, ViewState, void>): void;
    onsuspend$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontimeupdate(handler: JayEventHandler<Event, ViewState, void>): void;
    ontimeupdate$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontoggle(handler: JayEventHandler<Event, ViewState, void>): void;
    ontoggle$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontouchcancel(handler: JayEventHandler<TouchEvent, ViewState, void>): void;
    ontouchcancel$<EventData>(handler: JayEventHandler<TouchEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontouchend(handler: JayEventHandler<TouchEvent, ViewState, void>): void;
    ontouchend$<EventData>(handler: JayEventHandler<TouchEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontouchmove(handler: JayEventHandler<TouchEvent, ViewState, void>): void;
    ontouchmove$<EventData>(handler: JayEventHandler<TouchEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontouchstart(handler: JayEventHandler<TouchEvent, ViewState, void>): void;
    ontouchstart$<EventData>(handler: JayEventHandler<TouchEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitioncancel(handler: JayEventHandler<TransitionEvent, ViewState, void>): void;
    ontransitioncancel$<EventData>(handler: JayEventHandler<TransitionEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionend(handler: JayEventHandler<TransitionEvent, ViewState, void>): void;
    ontransitionend$<EventData>(handler: JayEventHandler<TransitionEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionrun(handler: JayEventHandler<TransitionEvent, ViewState, void>): void;
    ontransitionrun$<EventData>(handler: JayEventHandler<TransitionEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionstart(handler: JayEventHandler<TransitionEvent, ViewState, void>): void;
    ontransitionstart$<EventData>(handler: JayEventHandler<TransitionEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onvolumechange(handler: JayEventHandler<Event, ViewState, void>): void;
    onvolumechange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionstart(handler: JayEventHandler<Event, ViewState, void>): void;
    ontransitionstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionstart(handler: JayEventHandler<Event, ViewState, void>): void;
    ontransitionstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionstart(handler: JayEventHandler<Event, ViewState, void>): void;
    ontransitionstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    ontransitionstart(handler: JayEventHandler<Event, ViewState, void>): void;
    ontransitionstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onvolumechange(handler: JayEventHandler<Event, ViewState, void>): void;
    onvolumechange$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwaiting(handler: JayEventHandler<Event, ViewState, void>): void;
    onwaiting$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwebkitanimationend(handler: JayEventHandler<Event, ViewState, void>): void;
    onwebkitanimationend$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwebkitanimationiteration(handler: JayEventHandler<Event, ViewState, void>): void;
    onwebkitanimationiteration$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwebkitanimationstart(handler: JayEventHandler<Event, ViewState, void>): void;
    onwebkitanimationstart$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwebkittransitionend(handler: JayEventHandler<Event, ViewState, void>): void;
    onwebkittransitionend$<EventData>(handler: JayEventHandler<Event, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
    onwheel(handler: JayEventHandler<WheelEvent, ViewState, void>): void;
    onwheel$<EventData>(handler: JayEventHandler<WheelEvent, ViewState, EventData>): JayNativeEventBuilder<ViewState, EventData>;
}
interface HTMLElementCollectionProxyTarget<ViewState, ElementType extends HTMLElement> {
    addEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: boolean | AddEventListenerOptions): any;
    removeEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: EventListenerOptions | boolean): any;
    find(predicate: (t: ViewState, c: Coordinate) => boolean): HTMLNativeExec<ViewState, ElementType> | undefined;
    map<ResultType>(handler: (element: HTMLNativeExec<ViewState, ElementType>, viewState: ViewState, coordinate: Coordinate) => ResultType): Array<ResultType>;
}
interface HTMLElementCollectionProxy<ViewState, ElementType extends HTMLElement> extends GlobalJayEvents<ViewState>, HTMLElementCollectionProxyTarget<ViewState, ElementType> {
}
interface HTMLNativeExec<ViewState, ElementType extends HTMLElement> {
    exec$<ResultType>(handler: JayNativeFunction<ElementType, ViewState, ResultType>): Promise<ResultType>;
}
interface HTMLElementProxyTarget<ViewState, ElementType extends HTMLElement> extends HTMLNativeExec<ViewState, ElementType> {
    addEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: boolean | AddEventListenerOptions): any;
    removeEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: EventListenerOptions | boolean): any;
}
interface HTMLElementProxy<ViewState, ElementType extends HTMLElement> extends GlobalJayEvents<ViewState>, HTMLElementProxyTarget<ViewState, ElementType> {
}
/** Components references **/
interface EventEmitter<EventType, ViewState> {
    (handler: JayEventHandler<EventType, ViewState, void>): void;
    emit: (event?: EventType) => void;
}
type EventTypeFrom<Type> = Type extends EventEmitter<infer X, any> ? X : null;
type MapEventEmitterViewState<ParentViewState, ComponentType> = {
    [key in keyof ComponentType]: ComponentType[key] extends EventEmitter<infer T, any> ? EventEmitter<T, ParentViewState> : ComponentType[key];
};
type OnlyEventEmitters<ComponentType> = {
    [key in keyof ComponentType as ComponentType[key] extends EventEmitter<any, any> ? key : never]: ComponentType[key];
};
interface ComponentProxy<ViewState, ComponentType extends JayComponent<any, ViewState, any>> {
    addEventListener(type: string, handler: JayEventHandler<any, ViewState, void>, options?: boolean | AddEventListenerOptions): void;
    removeEventListener(type: string, handler: JayEventHandler<any, ViewState, void>, options?: EventListenerOptions | boolean): void;
}
interface ComponentCollectionProxy<ViewState, ComponentType extends JayComponent<any, any, any>> {
    addEventListener(type: string, handler: JayEventHandler<any, ViewState, void>, options?: boolean | AddEventListenerOptions): void;
    removeEventListener(type: string, handler: JayEventHandler<any, ViewState, void>, options?: EventListenerOptions | boolean): void;
    map<ResultType>(handler: (comp: ComponentType, viewState: ViewState, coordinate: Coordinate) => ResultType): Array<ResultType>;
    find(predicate: (t: ViewState) => boolean): ComponentType | undefined;
}

interface ManagedRefs {
    getPublicAPI(): any;
    mkManagedRef(currData: any, strings: Coordinate, eventWrapper: JayEventHandlerWrapper<any, any, any>): any;
}
declare function defaultEventWrapper<EventType, ViewState, Returns>(orig: JayEventHandler<EventType, ViewState, Returns>, event: JayEvent<EventType, ViewState>): Returns;
type ManagedRefConstructor = () => ManagedRefs;
type PrivateRefConstructor<ViewState> = () => PrivateRef<ViewState, any>;
declare enum ManagedRefType {
    element = 0,
    elementCollection = 1,
    component = 2,
    componentCollection = 3
}
declare abstract class BaseReferencesManager {
    readonly eventWrapper: JayEventHandlerWrapper<any, any, any>;
    private refs;
    private refsPublicAPI;
    constructor(eventWrapper?: JayEventHandlerWrapper<any, any, any>);
    abstract mkManagedRef(refType: ManagedRefType, refName: string): ManagedRefs;
    abstract currentContext(): {
        currData: any;
        coordinate: (refName: string) => Coordinate;
    };
    private mkRefsOfType;
    mkRefs<ViewState>(elem: string[], elemCollection: string[], comp: string[], compCollection: string[], childRefManagers?: Record<string, BaseReferencesManager>): PrivateRefConstructor<ViewState>[];
    private mkRefsPublicAPI;
    get(refName: string): ManagedRefs | BaseReferencesManager;
    getPublicAPI(): object;
    applyToElement<T, Refs>(element: BaseJayElement<T>): JayElement<T, Refs>;
}
declare class ReferencesManager extends BaseReferencesManager {
    mkManagedRef(refType: ManagedRefType): ManagedRefs;
    currentContext(): {
        currData: any;
        coordinate: (refName: string) => Coordinate;
    };
    static for(options: RenderElementOptions, elem: string[], elemCollection: string[], comp: string[], compCollection: string[], childRefManagers?: Record<string, ReferencesManager>): [ReferencesManager, PrivateRefConstructor<any>[]];
}

type ReferenceTarget<ViewState> = Element | JayComponent<any, ViewState, any>;
interface PrivateRef<ViewState, PublicRefAPI> {
    update: updateFunc<ViewState>;
    mount: MountFunc;
    unmount: MountFunc;
    viewState: ViewState;
    coordinate: Coordinate;
    getPublicAPI(): PublicRefAPI;
    set(referenced: ReferenceTarget<ViewState>): void;
    addEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<E extends Event>(type: string, handler: JayEventHandler<E, ViewState, any>, options?: EventListenerOptions | boolean): void;
}
declare abstract class PrivateRefs<ViewState, PublicRefAPI, RefType extends PrivateRef<ViewState, PublicRefAPI>> {
    protected elements: Set<RefType>;
    private listeners;
    addEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any>, options?: boolean | AddEventListenerOptions): void;
    addRef(ref: RefType): void;
    removeRef(ref: RefType): void;
    removeEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any>, options?: EventListenerOptions | boolean): void;
}
declare abstract class PrivateCollectionRefs<ViewState, PublicRefAPI, PublicCollectionRefAPI, RefType extends PrivateRef<ViewState, PublicRefAPI>> extends PrivateRefs<ViewState, PublicRefAPI, RefType> {
    map<ResultType>(handler: (referenced: PublicRefAPI, viewState: ViewState, coordinate: Coordinate) => ResultType): Array<ResultType>;
    find(predicate: (viewState: ViewState, c: Coordinate) => boolean): PublicRefAPI;
    abstract getPublicAPI(): PublicCollectionRefAPI;
}
declare class ComponentRefsImpl<ViewState, ComponentType extends JayComponent<any, ViewState, any>> extends PrivateRefs<ViewState, ComponentType, ComponentRefImpl<ViewState, ComponentType>> implements ManagedRefs {
    getInstance(): ComponentType;
    mkManagedRef(currData: any, coordinate: Coordinate, eventWrapper: JayEventHandlerWrapper<any, any, any>): ComponentRefImpl<ViewState, ComponentType>;
    getPublicAPI(): ComponentType;
}
declare class ComponentCollectionRefImpl<ViewState, ComponentType extends JayComponent<any, ViewState, any>> extends PrivateCollectionRefs<ViewState, ComponentType, ComponentCollectionProxy<ViewState, ComponentType>, ComponentRefImpl<ViewState, ComponentType>> implements ManagedRefs {
    mkManagedRef(currData: any, coordinate: Coordinate, eventWrapper: JayEventHandlerWrapper<any, any, any>): ComponentRefImpl<ViewState, ComponentType>;
    getPublicAPI(): ComponentCollectionProxy<ViewState, ComponentType>;
}
declare abstract class RefImpl<ViewState, ElementType extends ReferenceTarget<ViewState>, PublicRefAPI, RefType extends PrivateRef<ViewState, PublicRefAPI>> implements PrivateRef<ViewState, PublicRefAPI> {
    viewState: ViewState;
    coordinate: Coordinate;
    private eventWrapper;
    private parentCollection?;
    private listeners;
    protected element: ElementType;
    constructor(viewState: ViewState, coordinate: Coordinate, eventWrapper: JayEventHandlerWrapper<any, ViewState, any>, parentCollection?: PrivateRefs<ViewState, PublicRefAPI, RefType>);
    abstract getPublicAPI(): PublicRefAPI;
    set(referenced: ElementType | JayComponent<any, ViewState, any>): void;
    mount: () => void;
    unmount: () => void;
    abstract formatEvent(event: any): JayEvent<any, ViewState>;
    addEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any>, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any>, options?: EventListenerOptions | boolean): void;
    update: (newData: ViewState) => void;
}
declare class ComponentRefImpl<ViewState, ComponentType extends JayComponent<any, ViewState, any>> extends RefImpl<ViewState, ComponentType, ComponentType, ComponentRefImpl<ViewState, ComponentType>> {
    getFromComponent(prop: any): any;
    formatEvent(event: any): JayEvent<any, ViewState>;
    getPublicAPI(): ComponentType;
}
declare const EVENT_TRAP: (target: any, prop: any) => any;
declare const GetTrapProxy: (getTraps: ((target: any, p: string | symbol, receiver: any) => any)[]) => {
    get: (target: any, prop: any, receiver: any) => any;
};

declare function childComp<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, ref?: PrivateRef<ParentVS, ChildComp>): BaseJayElement<ParentVS>;
interface TextElement<ViewState> {
    dom: Text;
    update: updateFunc<ViewState>;
    mount: MountFunc;
    unmount: MountFunc;
}
declare const PROPERTY = 1;
declare const ATTRIBUTE = 2;
declare const BOOLEAN_ATTRIBUTE = 3;
type AttributeStyle = typeof PROPERTY | typeof ATTRIBUTE | typeof BOOLEAN_ATTRIBUTE;
interface DynamicAttributeOrProperty<ViewState, S> {
    valueFunc: (data: ViewState) => S;
    style: AttributeStyle;
}
declare function dynamicAttribute<ViewState>(attributeValue: (data: ViewState) => string): DynamicAttributeOrProperty<ViewState, string>;
declare function dynamicProperty<ViewState, S>(propertyValue: (data: ViewState) => S): DynamicAttributeOrProperty<ViewState, S>;
declare function booleanAttribute<ViewState, S>(propertyValue: (data: ViewState) => S): DynamicAttributeOrProperty<ViewState, S>;
type Attribute<ViewState, S> = string | DynamicAttributeOrProperty<ViewState, S> | Record<string, string | DynamicAttributeOrProperty<ViewState, S>>;
type Attributes<ViewState> = Record<string, Attribute<ViewState, any>>;
declare function conditional<ViewState>(condition: (newData: ViewState) => boolean, elem: () => BaseJayElement<ViewState> | TextElement<ViewState> | string): Conditional<ViewState>;
interface Conditional<ViewState> {
    condition: (newData: ViewState) => boolean;
    elem: () => BaseJayElement<ViewState> | TextElement<ViewState>;
}
declare enum WhenRole {
    pending = 0,
    resolved = 1,
    rejected = 2
}
interface When<ViewState, ResolvedViewValue> {
    role: WhenRole;
    promise: (newData: ViewState) => Promise<ResolvedViewValue>;
    elem: () => BaseJayElement<ResolvedViewValue> | TextElement<ResolvedViewValue> | string;
}
declare const resolved: <ViewState, ResolvedViewValue>(promise: (newData: ViewState) => Promise<ResolvedViewValue>, elem: () => string | BaseJayElement<ResolvedViewValue> | TextElement<ResolvedViewValue>) => When<ViewState, ResolvedViewValue>;
declare const rejected: <ViewState>(promise: (newData: ViewState) => Promise<any>, elem: () => BaseJayElement<Error> | TextElement<Error> | string) => When<ViewState, any>;
declare const pending: <ViewState>(promise: (newData: ViewState) => Promise<any>, elem: () => BaseJayElement<never> | TextElement<never> | string) => When<ViewState, any>;
declare function isCondition<ViewState>(c: Conditional<ViewState> | When<ViewState, any> | ForEach<ViewState, any> | WithData<ViewState, any> | TextElement<ViewState> | BaseJayElement<ViewState>): c is Conditional<ViewState>;
declare function isForEach<ViewState, Item>(c: Conditional<ViewState> | When<ViewState, any> | ForEach<ViewState, Item> | WithData<ViewState, any> | TextElement<ViewState> | BaseJayElement<ViewState>): c is ForEach<ViewState, Item>;
declare function isWhen<ViewState, Item>(c: Conditional<ViewState> | When<ViewState, any> | ForEach<ViewState, Item> | WithData<ViewState, any> | TextElement<ViewState> | BaseJayElement<ViewState>): c is When<ViewState, any>;
declare function isWithData<ViewState, ChildViewState>(c: Conditional<ViewState> | When<ViewState, any> | ForEach<ViewState, any> | WithData<ViewState, ChildViewState> | TextElement<ViewState> | BaseJayElement<ViewState>): c is WithData<ViewState, ChildViewState>;
declare function forEach<T, Item>(getItems: (T: any) => Array<Item>, elemCreator: (Item: any) => BaseJayElement<Item>, matchBy: string): ForEach<T, Item>;
interface ForEach<ViewState, Item> {
    getItems: (T: any) => Array<Item>;
    elemCreator: (Item: any, String: any) => BaseJayElement<Item>;
    trackBy: string;
}
declare function withData<ParentViewState, ChildViewState>(accessor: (data: ParentViewState) => ChildViewState | null | undefined, elem: () => BaseJayElement<ChildViewState>): WithData<ParentViewState, ChildViewState>;
interface WithData<ParentViewState, ChildViewState> {
    accessor: (data: ParentViewState) => ChildViewState | null | undefined;
    elem: () => BaseJayElement<ChildViewState>;
}
declare function mkUpdateCollection<ViewState, Item>(child: ForEach<ViewState, Item>, group: KindergartenGroup): [updateFunc<ViewState>, MountFunc, MountFunc];
declare function dynamicText<ViewState>(textContent: (vs: ViewState) => string | number | boolean): TextElement<ViewState>;
interface HtmlContent<ViewState> {
    __htmlContent: true;
    htmlAccessor: (vs: ViewState) => string;
}
declare function dynamicHtml<ViewState>(htmlContent: (vs: ViewState) => string): HtmlContent<ViewState>;
declare function isHtmlContent(child: any): child is HtmlContent<any>;
declare function applyHtmlContent<ViewState>(child: HtmlContent<ViewState>, parentElement: Element, updates: updateFunc<ViewState>[], skipInitial?: boolean): void;
type ElementChildren<ViewState> = Array<BaseJayElement<ViewState> | TextElement<ViewState> | HtmlContent<ViewState> | string>;
declare const element: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: ElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare const svgElement: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: ElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare const mathMLElement: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: ElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
type DynamicElementChildren<ViewState> = Array<Conditional<ViewState> | ForEach<ViewState, any> | WithData<ViewState, any> | TextElement<ViewState> | BaseJayElement<ViewState> | HtmlContent<ViewState> | When<ViewState, any> | string>;
declare const dynamicElementNS: (ns: string) => <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: DynamicElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare const dynamicElement: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: DynamicElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare const svgDynamicElement: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: DynamicElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare const mathMLDynamicElement: <ViewState>(tagName: string, attributes: Attributes<ViewState>, children?: DynamicElementChildren<ViewState>, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>) => BaseJayElement<ViewState>;
declare function normalizeUpdates<ViewState>(updates: Array<updateFunc<ViewState>>): updateFunc<ViewState>;
declare function normalizeMount(mounts: Array<MountFunc>): MountFunc;
interface HeadLink {
    rel: string;
    href: string;
    attributes?: Record<string, string>;
}
declare function injectHeadLinks(headLinks: HeadLink[]): void;

interface ContextStack<ContextType> {
    context: ContextType;
    marker: ContextMarker<ContextType>;
    parent?: ContextStack<any>;
}
/**
 * Registers a global context that will be available to all components.
 * Global contexts are checked after the context stack, so component-provided
 * contexts can override global ones.
 *
 * @param marker - The context marker created with createJayContext()
 * @param context - The context value to register
 *
 * @example
 * ```typescript
 * // In lib/init.ts (using makeJayInit pattern)
 * export const init = makeJayInit()
 *   .withServer(() => ({ itemsPerPage: 10 }))
 *   .withClient((serverData) => {
 *     registerGlobalContext(APP_CONFIG_CONTEXT, serverData);
 *   });
 * ```
 */
declare function registerGlobalContext<ContextType>(marker: ContextMarker<ContextType>, context: ContextType): void;
/**
 * Clears all registered global contexts.
 * Internal API for testing and hot reload.
 */
declare function clearGlobalContextRegistry(): void;
/**
 * Gets a global context by marker.
 * Internal API used by findContext.
 */
declare function useGlobalContext<ContextType>(marker: ContextMarker<ContextType>): ContextType | undefined;
declare function createJayContext<ContextType = unknown>(name: string): ContextMarker<ContextType>;
declare function withContext<ContextType, Returns>(marker: ContextMarker<ContextType>, context: ContextType, callback: () => Returns): Returns;
declare function useContext<ContextType>(marker: ContextMarker<ContextType>): ContextType;
declare function findContext<ContextType>(predicate: (marker: ContextMarker<ContextType>) => boolean): ContextType | undefined;
declare function saveContext(): ContextStack<any>;
declare function restoreContext<Returns>(savedContext: ContextStack<any>, callback: () => Returns): Returns;
declare function currentConstructionContext(): ConstructContext<any>;
declare class ConstructContext<ViewState> {
    private readonly data;
    readonly forStaticElements: boolean;
    private readonly coordinateBase;
    private readonly _coordinateMap?;
    private readonly _rootElement?;
    private readonly _dataIds;
    readonly sanitizeHtml?: (html: string) => string;
    constructor(data: ViewState, forStaticElements?: boolean, coordinateBase?: Coordinate, coordinateMap?: Map<string, Element[]>, rootElement?: Element, dataIds?: Coordinate, sanitizeHtml?: (html: string) => string);
    get currData(): ViewState;
    /** The accumulated trackBy values from ancestor forEach loops (for __headlessInstances key lookup) */
    get dataIds(): Coordinate;
    coordinate: (refName: string) => Coordinate;
    /**
     * Create a child context for a forEach item.
     *
     * With scoped coordinates (DL#126), coordinateBase is NOT accumulated —
     * scoped coordinates are fully qualified within each scope. Only dataIds
     * accumulates (for __headlessInstances key lookup).
     *
     * coordinateBase is still maintained for the non-hydration path where
     * coordinate() is used for refs.
     */
    forItem<ChildViewState>(childViewState: ChildViewState, id: string): ConstructContext<ChildViewState>;
    /**
     * Create a child context scoped to a DOM subtree (DL#126).
     *
     * Builds a LOCAL coordinate map from the scope root element's subtree.
     * All coordinate lookups within this scope search the local map only.
     * This ensures forEach items with shared scope IDs resolve correctly —
     * each item builds its own local map from its own DOM branch.
     */
    forScope(scopeRootElement: Element): ConstructContext<ViewState>;
    forAsync<ChildViewState>(childViewState: ChildViewState): ConstructContext<ChildViewState>;
    /** Whether this context is in hydration mode (adopting existing DOM). */
    get isHydrating(): boolean;
    /** The root element being hydrated (undefined in non-hydration mode). */
    get rootElement(): Element | undefined;
    /**
     * Resolve an element by its coordinate key from the hydration map.
     *
     * With scoped coordinates (DL#126), the key is fully qualified within the
     * scope (e.g., "S2/0"). No coordinateBase prefix is applied — coordinates
     * are self-contained within their scope.
     *
     * When multiple elements share the same coordinate (e.g., forEach items
     * sharing the same template scope IDs), each call returns the next element
     * in document order.
     */
    resolveCoordinate(key: string): Element | undefined;
    /**
     * Peek at an element by its coordinate key without consuming it.
     * Used by hydrateForEach to resolve the container element — the same element
     * is also consumed by the parent adoptElement call (which evaluates after
     * hydrateForEach due to JavaScript argument evaluation order).
     */
    peekCoordinate(key: string): Element | undefined;
    static withRootContext<ViewState, Refs>(viewState: ViewState, refManager: ReferencesManager, elementConstructor: () => BaseJayElement<ViewState>, sanitizeHtml?: (html: string) => string): JayElement<ViewState, Refs>;
    /**
     * Hydrate a child component's inline template within the parent's coordinate scope.
     *
     * Like withRootContext, but inherits the coordinateBase and coordinateMap from
     * the current (parent) ConstructContext. This allows adoptElement/adoptText calls
     * inside the child to resolve coordinates scoped to the child's prefix.
     *
     * Used by headless component instances during hydration: the parent pushes a
     * scoped context (via childCompHydrate), and the child's preRender calls this
     * method which inherits the scoped coordinateBase.
     */
    static withHydrationChildContext<ViewState, Refs>(viewState: ViewState, refManager: ReferencesManager, elementConstructor: () => BaseJayElement<ViewState>): JayElement<ViewState, Refs>;
    /**
     * Hydrate existing server-rendered DOM.
     *
     * Builds a coordinate→element map from all [jay-coordinate] attributes
     * inside rootElement, creates a ConstructContext in hydration mode,
     * pushes it onto the context stack, then calls hydrateConstructor.
     *
     * The hydrateConstructor calls adoptText(), adoptElement(), etc. which
     * read from the context stack — same pattern as element(), dynamicText().
     * It returns a BaseJayElement whose update/mount/unmount are composed
     * from all adopted children — same as withRootContext's elementConstructor.
     */
    static withHydrationRootContext<ViewState, Refs>(viewState: ViewState, refManager: ReferencesManager, rootElement: Element, hydrateConstructor: () => BaseJayElement<ViewState>): JayElement<ViewState, Refs>;
}

/**
 * Sentinel value for static children in adoptDynamicElement.
 * Represents a child position occupied by a pre-existing DOM node
 * that has no hydration code (no dynamic text, no dynamic attributes, no refs).
 */
declare const STATIC: unique symbol;
/** Element returned by hydrateForEach/hydrateConditional that needs a group assigned later. */
type DynamicChild<ViewState> = BaseJayElement<ViewState> & {
    _setGroup: (group: KindergartenGroup) => void;
};
/**
 * Adopt an existing text node inside the element at the given coordinate.
 *
 * Reads the current ConstructContext from the stack (via currentConstructionContext())
 * to resolve the coordinate to an existing DOM element. Finds the text child at
 * the given index (by significant-child position) and connects a dynamic text updater.
 *
 * - coordinate: element containing the text (or parent in mixed content)
 * - accessor: (vs) => string | number | boolean
 * - ref?: optional ref for the element
 * - childIndex?: index among significant children (default 0). Use when parent has
 *   mixed content (text + elements); matches element target's positional dynamicText.
 */
declare function adoptText<ViewState>(coordinate: string, accessor: (vs: ViewState) => string | number | boolean, ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>, childIndex?: number): BaseJayElement<ViewState>;
/**
 * Adopt an existing element at the given coordinate, connecting dynamic
 * attributes and adopted children to it.
 *
 * Hydration counterpart to element() — adopts server-rendered HTML and wires
 * up dynamic attribute bindings and children.
 */
declare function adoptElement<ViewState>(coordinate: string, attributes: Attributes<ViewState>, children?: (BaseJayElement<ViewState> | HtmlContent<ViewState>)[], ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>): BaseJayElement<ViewState>;
/**
 * Adopt an existing element that has interactive children (forEach/conditional).
 *
 * Creates one Kindergarten per parent, one group per child position.
 * STATIC sentinels represent children with no hydrate code.
 * Children with `_setGroup` (forEach/conditional) receive their group via callback.
 */
declare function adoptDynamicElement<ViewState>(coordinate: string, attributes: Attributes<ViewState>, children?: (BaseJayElement<ViewState> | typeof STATIC)[], ref?: PrivateRef<ViewState, BaseJayElement<ViewState>>): BaseJayElement<ViewState>;
/**
 * Hydration-aware conditional.
 *
 * Returns an element with `_setGroup` callback. The parent `adoptDynamicElement`
 * calls `_setGroup` to assign a KindergartenGroup, which is used for DOM
 * positioning (ensureNode/removeNode) instead of anchor comments.
 *
 * Handles two cases:
 * - **True at SSR**: Element exists in DOM. Adopt it, register in group, wire toggle.
 * - **False at SSR**: Element absent. Use createFallback to lazily create when true.
 */
declare function hydrateConditional<ViewState>(condition: (vs: ViewState) => boolean, adoptExisting: () => BaseJayElement<ViewState>, createFallback?: () => BaseJayElement<ViewState>): DynamicChild<ViewState>;
/**
 * Hydration-aware forEach.
 *
 * Adopts existing items that were server-rendered, and creates new items via
 * the regular element creation path when the list changes.
 *
 * Returns an element with `_setGroup` callback. The parent `adoptDynamicElement`
 * calls `_setGroup` to assign a KindergartenGroup from the parent's Kindergarten,
 * ensuring correct DOM positioning relative to siblings.
 *
 * @param accessor - Function to get the array from the ViewState
 * @param trackBy - Property name used for item identity (reconciliation key)
 * @param itemCoordinate - Scoped coordinate of each forEach item root element (DL#126).
 *   All items share this coordinate; each resolveCoordinate call consumes the next one.
 * @param adoptItem - Called per existing item during hydration (should use adoptText/adoptElement)
 * @param createItem - Called per new item (regular element()/dynamicText() from generated-element.ts)
 */
declare function hydrateForEach<ViewState, Item>(accessor: (vs: ViewState) => Item[], trackBy: string, itemCoordinate: string, adoptItem: () => BaseJayElement<Item>[], createItem: (item: Item, id: string) => BaseJayElement<Item>): DynamicChild<ViewState>;
/**
 * Hydration-aware child component instantiation.
 *
 * With scoped coordinates (DL#126), the child component creates a LOCAL
 * coordinate map from its inline template root element's subtree.
 * This ensures the child's adopt calls resolve against the correct DOM
 * branch, not the global map.
 *
 * @param compCreator - Component factory (from makeHeadlessInstanceComponent)
 * @param getProps - Extracts component props from parent ViewState
 * @param scopeRootCoordinate - Coordinate of the inline template root element (e.g., "S2/0")
 * @param ref - Optional ref for the component instance
 */
declare function childCompHydrate<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, scopeRootCoordinate?: string, ref?: PrivateRef<ParentVS, ChildComp>): BaseJayElement<ParentVS>;

export { type Attribute, type Attributes, type BaseJayElement, BaseReferencesManager, type ComponentCollectionProxy, ComponentCollectionRefImpl, type ComponentProxy, ComponentRefImpl, ComponentRefsImpl, type Conditional, ConstructContext, type ContextMarker, type Coordinate, type DynamicAttributeOrProperty, EVENT_TRAP, type ElementFrom, type EventEmitter, type EventTypeFrom, type ExtractFastViewState, type ExtractInteractiveViewState, type ExtractProps, type ExtractRefs, type ExtractSlowViewState, type ExtractViewState, type ForEach, GetTrapProxy, type GlobalJayEvents, type HTMLElementCollectionProxy, type HTMLElementCollectionProxyTarget, type HTMLElementProxy, type HTMLElementProxyTarget, type HTMLNativeExec, type HeadLink, type HtmlContent, type JayComponent, type JayComponentConstructor, type JayContract, type JayElement, type JayEvent, type JayEventHandler, type JayEventHandlerWrapper, type JayLog, type JayNativeEventBuilder, type JayNativeFunction, LogType, type ManagedRefConstructor, ManagedRefType, type ManagedRefs, type MapEventEmitterViewState, type MountFunc, type OnlyEventEmitters, type PreRenderElement, type PrivateRef, type PrivateRefConstructor, PrivateRefs, type PropsFrom, ReferencesManager, type RenderElement, type RenderElementOptions, STATIC, type TextElement, VIEW_STATE_CHANGE_EVENT, type ViewStateFrom, type When, WhenRole, type WithData, adoptDynamicElement, adoptElement, adoptText, applyHtmlContent, booleanAttribute, childComp, childCompHydrate, clearGlobalContextRegistry, conditional, createJayContext, currentConstructionContext, defaultEventWrapper, dynamicAttribute, dynamicElement, dynamicElementNS, dynamicHtml, dynamicProperty, dynamicText, element, findContext, forEach, hydrateConditional, hydrateForEach, injectHeadLinks, isCondition, isForEach, isHtmlContent, isWhen, isWithData, jayLog, mathMLDynamicElement, mathMLElement, mkUpdateCollection, noop, noopMount, noopUpdate, normalizeMount, normalizeUpdates, pending, registerGlobalContext, rejected, resolved, restoreContext, saveContext, svgDynamicElement, svgElement, type updateFunc, useContext, useGlobalContext, withContext, withData };