import { StaticBlockDef } from '../static-block';
import { AnyCell, Cell, tagOp } from '../reactive';
import { BasicListComponent } from './list';

/** Per-row frame record — the ONLY per-row state frame mode keeps. */
export interface EachFrame<T> {
    /** The cloned single-root row element. IS the row boundary (no marker). */
    root: Node;
    /** Slot nodes, parallel to the block's slot table. */
    nodes: Node[];
    /** Raw positional slot values from `blockValues(item, index, list)`. */
    thunks: readonly unknown[];
    /** Last APPLIED values (per-kind normalized), parallel to the slot table. */
    values: unknown[];
    item: T;
    /** Position as of the last sync (feeds the LIS move phase). */
    index: number;
    /** Item-owned dep cells subscribed for this row (null until first dep). */
    itemCells: AnyCell[] | null;
    /** subscribeOp cleanups, parallel to itemCells. */
    itemUnsubs: Array<() => void> | null;
    /** Slot indices with item-cell deps — what `itemOp` re-runs. */
    itemSlots: number[] | null;
    /** The row's single update op (reused across rebinds). */
    itemOp: tagOp | null;
    /** `cellsMap.get(item)` snapshot at bind/rebind (item-cell classification —
     * avoids a WeakMap get per slot run). */
    bag: Map<string | number | symbol, Cell<unknown>> | undefined;
}
/** One list-level subscription per distinct shared (non-item) dep cell. */
export interface FrameSharedEntry {
    /** Union of slot indices (across rows) that tracked this cell. */
    slots: number[];
    unsub: () => void;
}
/** Runtime frame-mode qualification over the compiled slot table. */
export declare function framesQualify(block: StaticBlockDef): boolean;
/** Ember-host detection — hosts keep the v1 formula-based bindings.
 *
 * Detects host integration via the cross-instance `__gxtHostHooksInstalled`
 * sentinel (set by `registerHostHooks`, the formal API) OR the legacy
 * `globalThis.__gxt*` hook slots (pre-API integration that mutates globals).
 * The sentinel is required: a host that wires its channels through
 * `registerHostHooks` writes them into the module-local HOST_HOOKS, which a
 * differently-bundled frame-gate copy cannot see — so a hooks-table probe
 * would miss it and frame mode would wrongly engage, breaking the host's
 * formula-based reactivity bridge. */
export declare function frameHostHooksInstalled(): boolean;
type AnyList = BasicListComponent<any>;
/**
 * Tear down every frame. Bulk-clears the parent DOM (O(1) innerHTML='') when
 * this list owns it end-to-end — the same guard `fastCleanup` uses — falling
 * back to per-root removal otherwise. Frame teardown is just "run the
 * unsubs": frame rows have no modifiers/components, so no destructor cascade
 * exists to run.
 */
export declare function clearAllFrames(list: AnyList): void;
/**
 * Full frame-state teardown for the LIST's own destruction: frames + the
 * list-level shared-dep subscriptions. Idempotent (the list destructor and
 * the `syncList([])` teardown destructor can both reach it).
 */
export declare function destroyFrameState(list: AnyList): void;
/**
 * The frame-mode keyed sync (replaces updateItems/fastCleanup/destroyItem for
 * frame lists). Same observable keyed semantics as v1: position-qualified
 * duplicate keys (via the list's own `keyForItem`), removals before
 * insertions, LIS-minimal relocation, append/replace/clear fast paths.
 * Inverse rendering stays with the caller (the subclass syncList wrappers).
 */
export declare function syncFrames<T extends {
    id: number;
}>(list: BasicListComponent<T>, items: T[]): void;
export {};