/**
 * Perfect Reactivity - Computed
 *
 * Derived reactive values that automatically update when dependencies change.
 */
import type { ComputedNode, Link } from './core';
/**
 * Computed - derived reactive value with automatic dependency tracking
 *
 * @template T - Value type
 *
 * @example
 * ```ts
 * const count = signal(0);
 * const double = computed(() => count.read() * 2);
 * console.log(double.read()); // 0
 * count.write(5);
 * console.log(double.read()); // 10
 * ```
 */
export declare class IComputed<T = any> implements ComputedNode {
    fn: () => T;
    value: any;
    flags: number;
    deps: Link | null;
    depsTail: Link | null;
    subs: Link | null;
    subsTail: Link | null;
    version: number;
    lastCheckCycle: number;
    constructor(fn: () => T);
    /**
     * Read computed value and track dependency in current reactive context
     *
     * Lazily computes value only when accessed and dependencies have changed.
     *
     * @returns Current computed value
     */
    read(): T;
    /**
     * Read value without tracking dependency or updating
     *
     * @returns Current cached value (may be stale)
     */
    peek(): T;
}
/**
 * Create a computed value with automatic dependency tracking
 *
 * @template T - Value type
 * @param fn - Computation function
 * @returns Computed instance
 *
 * @example
 * ```ts
 * const count = signal(0);
 * const double = computed(() => count.read() * 2);
 * const quadruple = computed(() => double.read() * 2);
 * ```
 */
export declare function computed<T>(fn: () => T): IComputed<T>;
export type { IComputed as ComputedOptions };