/**
 * JQHTML Data Proxy System
 *
 * Extracted from component.ts - handles:
 * - Data freeze/unfreeze enforcement via Proxy
 * - Detached on_load() / on_load_error() execution with restricted access
 */
/**
 * `this.data[RAW_DATA]` is the RAW object behind the freeze proxy. Framework code
 * that only READS the whole of this.data (serializing it for change detection) goes
 * through it, so it does not build a read-only wrapper for every nested object it
 * walks while this.data is frozen. A symbol: no key in author data can collide with
 * it, and Object.keys / for..in / JSON never see it.
 */
export declare const RAW_DATA: unique symbol;
/**
 * Set up the `this.data` property on a component using Object.defineProperty
 * with a Proxy that enforces freeze/unfreeze semantics.
 *
 * After setup:
 * - `this.data` reads/writes go through a Proxy
 * - When `component.__data_frozen === true`, every mutation route throws: assignment,
 *   delete, Object.defineProperty, Object.setPrototypeOf, Object.preventExtensions /
 *   seal / freeze - on this.data and, through the read-only wrappers, on anything
 *   nested in it. A property descriptor's value is the read-only wrapper too.
 * - When frozen is false, writes pass through normally
 *
 * @param component - The component instance to set up data on
 */
export declare function setup_data_property(component: any): void;
/**
 * `this[LOAD_HOOK_OWNER]` on the restricted `this` of on_load()/on_load_error() is the
 * real component. Framework code reached from inside the hook - the base
 * on_load_error(), called by an override through super - uses it to name the
 * component. A module symbol: author code cannot reach it, and the restriction on
 * every other property stays in force.
 */
export declare const LOAD_HOOK_OWNER: unique symbol;
/**
 * Execute on_load() in a detached context with restricted access (see
 * create_detached_context()).
 *
 * @param component - The component instance
 * @param dedup_key - The dedup key captured by the caller, or null to run uncoordinated.
 *                    The key is passed in rather than recomputed because args may legally
 *                    change while on_load() runs, and a recomputed key would address a
 *                    different entry than the one this leader registered.
 * @returns The resulting data and optional coordination completion function
 */
export declare function execute_on_load_detached(component: any, dedup_key?: string | null): Promise<{
    data: Record<string, any>;
    complete_coordination: ((final_text: string | null) => void) | null;
}>;
/**
 * Execute an on_load_error() override in the same detached context as on_load(): read
 * this.args, write this.data (starting again from the on_create() snapshot), nothing
 * else. Never coordinated - fallback data is never handed to deduplication followers.
 *
 * @returns The data the hook left in this.data (the fallback); throws what the hook throws
 */
export declare function execute_on_load_error_detached(component: any, error: any): Promise<Record<string, any>>;
//# sourceMappingURL=data-proxy.d.ts.map