/** 依存を持つ側(再計算・再実行される側)。 */
type Sub = Computed<unknown> | Effect;
/** 購読される側。 */
type Dep = Reactive<unknown>;
/** scope に登録できるもの。 */
export type Disposable = {
    dispose(): void;
} | (() => void);
/** いま溜まっている更新を即座に反映する(テスト・同期的にDOMを測りたい時)。 */
export declare function flushSync(): void;
/** DOM への反映を待つ。 await tick() の後は画面が最新。 */
export declare function tick(): Promise<void>;
/** fn 内の複数の書き込みを1回の更新にまとめる。 */
export declare function batch<T>(fn: () => T): T;
/** 依存として登録せずに読む(この中の get は購読を張らない)。 */
export declare function untrack<T>(fn: () => T): T;
export declare class Reactive<T> {
    subs: Set<Sub>;
    version: number;
    /** 現在値を読む(依存として記録される)。 */
    get(): T;
    /** 購読せずに現在値を覗く。 */
    peek(): T;
    /**
     * 値の変化を購読する(登録直後に現在値で1回呼ぶ = Svelte store と同じ作法)。
     * 戻り値は購読解除関数。DOM 束縛層はこれだけを使う。
     */
    subscribe(cb: (value: T) => void): () => void;
}
export declare class Signal<T> extends Reactive<T> {
    _value: T;
    constructor(initial: T);
    get(): T;
    peek(): T;
    set(next: T): void;
    update(fn: (current: T) => T): void;
}
export declare class Computed<T> extends Reactive<T> {
    fn: () => T;
    _value: T | undefined;
    _deps: Map<Dep, number>;
    _ready: boolean;
    _computing: boolean;
    constructor(fn: () => T);
    get(): T;
    peek(): T;
    /** 必要なら再計算して自分を最新にする。 */
    _pull(): void;
    _stale(): boolean;
    _recompute(): void;
    /** 上流とのリンクを切る(scope 破棄時に呼ばれる)。 */
    dispose(): void;
}
export declare class Effect {
    fn: () => void | (() => void);
    _deps: Map<Dep, number>;
    _cleanup: (() => void) | null;
    _disposed: boolean;
    constructor(fn: () => void | (() => void));
    run(): void;
    /** 上流が本当に変わっていれば実行する(グリッチ・無駄な再描画の抑止)。 */
    _runIfStale(): void;
    dispose(): void;
}
export declare class Scope {
    _disposers: Disposable[];
    _disposed: boolean;
    constructor(parent?: Scope | null);
    add<T extends Disposable>(disposable: T): T;
    /** この scope を現在の scope にして fn を実行する。 */
    run<T>(fn: (scope: Scope) => T): T;
    dispose(): void;
}
/** 書き込める状態を作る。 */
export declare function signal<T>(initial: T): Signal<T>;
/** 派生状態を作る。依存は自動追跡、評価は遅延。 */
export declare function computed<T>(fn: () => T): Computed<T>;
/**
 * 副作用。生成時に1回実行し、以後は依存が変わるたびに再実行。
 * fn が関数を返すとそれが「次回実行前 / 破棄時」の後片付けになる。
 * 戻り値は破棄関数。現在の scope があれば自動登録される。
 */
export declare function effect(fn: () => void | (() => void)): () => void;
/**
 * 片付けの単位を作る。
 *   const s = scope(() => { ... ここで張った購読は s に紐づく ... });
 *   s.dispose();
 */
export declare function scope(fn?: (scope: Scope) => void): Scope;
/** 現在の scope(なければ null)。DOM 層が要素と scope を結びつけるのに使う。 */
export declare function currentScope(): Scope | null;
/** リアクティブな値(Signal / Computed)か。 */
export declare function isReactive(x: unknown): x is Reactive<unknown>;
/** 書き込めるか(Computed は読み取り専用)。 */
export declare function isWritable(x: unknown): x is Signal<unknown>;
export {};