/**
 * Derived<T> -- computed reactive value.
 *
 * @module
 */
import type { Scope } from 'effect';
import { Effect, Stream } from 'effect';
import type { Cell } from './cell.js';
interface DerivedShape<T> {
    readonly _tag: 'Derived';
    readonly changes: Stream.Stream<T>;
    readonly get: Effect.Effect<T>;
}
/**
 * Derived — read-only reactive view computed from upstream {@link Cell}s.
 * A `Derived` recomputes lazily and pushes the new value into its own stream
 * when any dependency changes; composes via `combine`, `map`, and `flatten`.
 */
export declare const Derived: {
    /** Build a derived cell from a factory computing against upstream sources. */
    make: <T>(compute: Effect.Effect<T>, sources?: ReadonlyArray<Stream.Stream<unknown>>) => Effect.Effect<DerivedShape<T>, never, Scope.Scope>;
    /** Combine multiple cells into a single derived cell of their tuple. */
    combine: <T extends readonly unknown[], U>(cells: { [K in keyof T]: Cell.Shape<T[K]>; }, combiner: (...args: T) => U) => Effect.Effect<DerivedShape<U>, never, Scope.Scope>;
    /** Pure projection of an existing cell/derived. */
    map: <A, B>(derived: DerivedShape<A>, f: (a: A) => B) => Effect.Effect<DerivedShape<B>, never, Scope.Scope>;
    /** Flatten a derived-of-derived into a single derived of the inner value. */
    flatten: <T>(nested: DerivedShape<DerivedShape<T>>) => Effect.Effect<DerivedShape<T>, never, Scope.Scope>;
};
export declare namespace Derived {
    /** Structural shape of a {@link Derived}: `_tag`, `get`, `changes`. */
    type Shape<T> = DerivedShape<T>;
}
export {};
//# sourceMappingURL=derived.d.ts.map