/**
 * Cell<T> -- writable reactive primitive.
 *
 * @module
 */
import type { Scope } from 'effect';
import { Effect, Stream, SubscriptionRef } from 'effect';
interface CellShape<T> {
    readonly _tag: 'Cell';
    readonly ref: SubscriptionRef.SubscriptionRef<T>;
    readonly changes: Stream.Stream<T>;
    readonly get: Effect.Effect<T>;
    set(value: T): Effect.Effect<void>;
    update(f: (current: T) => T): Effect.Effect<void>;
}
/**
 * Read all values from a tuple of cells, preserving the tuple type `T`.
 *
 * Sanctioned single cast site for Cell combinators. Two type-system gaps force
 * this containment:
 *   1. `tupleMap`'s callback signature collapses to `U = Effect<T[number]>`,
 *      losing the per-element `Effect<T[K]>` relationship.
 *   2. `Effect.all`'s tuple overload returns a mapped-tuple result
 *      `{ -readonly [K in keyof ...]: _A }` that TypeScript cannot fold back
 *      to the input tuple type `T` (`T` could be instantiated with an
 *      arbitrary subtype per the structural contravariance rules).
 *
 * The runtime behavior is provably correct: `tupleMap` is total and order-
 * preserving, `Effect.all` with an array input preserves positional order and
 * arity, so the resulting values are `T` by construction.
 */
export declare const readAllCellValues: <T extends readonly unknown[]>(cells: { readonly [K in keyof T]: CellShape<T[K]>; }) => Effect.Effect<T>;
/**
 * Cell — mutable reactive primitive backed by `SubscriptionRef`.
 * The workhorse of czap's reactive graph: `get` for a snapshot, `set` to
 * push, `changes` for the stream of subsequent values.
 */
export declare const Cell: {
    /** Build a cell with an initial value. */
    make: <T>(initial: T) => Effect.Effect<CellShape<T>>;
    /** Seed a cell with an initial value and mirror every stream emission into it. */
    fromStream: <T>(initial: T, source: Stream.Stream<T>) => Effect.Effect<CellShape<T>, never, Scope.Scope>;
    /** Tuple-combine cells into a single cell of their current values. */
    all: <const T extends readonly unknown[]>(cells: { readonly [K in keyof T]: CellShape<T[K]>; }) => Effect.Effect<CellShape<T>, never, Scope.Scope>;
    /** Scoped `map` — derive a new cell by applying `fn` to every emission. */
    map: <T, U>(cell: CellShape<T>, fn: (value: T) => U) => Effect.Effect<CellShape<U>, never, Scope.Scope>;
};
export declare namespace Cell {
    /** Structural shape of a {@link Cell}: `_tag`, `get`, `set`, `changes`. */
    type Shape<T> = CellShape<T>;
}
export {};
//# sourceMappingURL=cell.d.ts.map