/**
 * Perfect Reactivity - Core Implementation
 *
 * High-performance fine-grained reactive system featuring:
 * - Hybrid pull-push propagation model
 * - Glitch-free updates via topological ordering
 * - Optimized dependency tracking with linked lists
 * - Automatic batching and effect scheduling
 */
/** Global version counter incremented on each signal write */
export declare let globalVersion: number;
/** Current tracking context during reactive execution */
export declare let trackingContext: ComputedNode | EffectNode | null;
/** Batch nesting depth for nested batch operations */
export declare let batchDepth: number;
/** Effects queued during batch or propagation phase */
export declare let batchedEffects: EffectNode[] | null;
/**
 * Dependency link between reactive nodes
 *
 * Forms a bidirectional doubly-linked list structure for efficient
 * dependency tracking and traversal.
 */
export type Link = {
    /** Dependency node (source) */
    dep: SignalNode | ComputedNode | null;
    /** Subscriber node (target) */
    sub: ComputedNode | EffectNode | null;
    /** Cached version for staleness checks */
    version: number;
    /** Next dependency in subscriber's dep list */
    nextDep: Link | null;
    /** Previous dependency in subscriber's dep list */
    prevDep: Link | null;
    /** Next subscriber in dependency's sub list */
    nextSub: Link | null;
    /** Previous subscriber in dependency's sub list */
    prevSub: Link | null;
};
/**
 * Signal node - reactive data source
 *
 * Stores mutable state and tracks subscribers.
 */
export type SignalNode = {
    /** Current value */
    value: any;
    /** Head of subscriber list */
    subs: Link | null;
    /** Tail of subscriber list (for O(1) appends) */
    subsTail: Link | null;
    /** Version for change detection */
    version: number;
};
/**
 * Creates a new signal node
 *
 * @param value - Initial value
 * @returns Signal node
 */
export declare function createSignalNode(value: any): SignalNode;
/**
 * Reads signal value and tracks dependency
 *
 * @param node - Signal node to read
 * @returns Current signal value
 */
export declare function signalRead(node: SignalNode): any;
/**
 * Writes new value to signal and propagates changes
 *
 * @param node - Signal node to write
 * @param value - New value
 */
export declare function signalWrite(node: SignalNode, value: any): void;
/**
 * Computed node - derived reactive value
 *
 * Caches computed results and tracks both dependencies and subscribers.
 * Uses lazy evaluation with memoization for optimal performance.
 *
 * @remarks
 * Flags: 0x1 = Dirty, 0x4 = Computing
 */
export type ComputedNode = {
    /** Computation function (also serves as type marker) */
    fn: () => any;
    /** Cached computed value */
    value: any;
    /** Head of dependency list */
    deps: Link | null;
    /** Tail of dependency list */
    depsTail: Link | null;
    /** Head of subscriber list */
    subs: Link | null;
    /** Tail of subscriber list */
    subsTail: Link | null;
    /** Version for change detection */
    version: number;
    /** State flags (dirty, computing) */
    flags: number;
    /** Last check cycle for memoization */
    lastCheckCycle: number;
};
export declare function createComputedNode(fn: () => any): ComputedNode;
export declare function computedRead(node: ComputedNode): any;
export declare function computedUpdateIfNecessary(node: ComputedNode): void;
export declare function computedUpdate(node: ComputedNode): void;
export declare function computedDispose(node: ComputedNode): void;
/**
 * Effect node - side effect that runs when dependencies change
 *
 * Tracks dependencies and automatically re-executes when they update.
 * Effects are batched and scheduled for optimal performance.
 *
 * @remarks
 * Flags: 0x1 = Dirty, 0x2 = InBatch, 0x4 = Computing, 0x8 = Disposed
 */
export type EffectNode = {
    /** Effect function (also serves as type marker) */
    fn: () => void;
    /** State flags (dirty, batched, computing, disposed) */
    flags: number;
    /** Head of dependency list */
    deps: Link | null;
    /** Tail of dependency list */
    depsTail: Link | null;
};
export declare function createEffectNode(fn: () => void): EffectNode;
export declare function effectExecute(node: EffectNode): void;
export declare function effectNotify(node: EffectNode): void;
export declare function effectDispose(node: EffectNode): void;
export declare function link(dep: SignalNode | ComputedNode, sub: ComputedNode | EffectNode): void;
export declare function startBatch(): void;
export declare function endBatch(): void;