@typed/fx 1.32.0 → 2.0.0-beta.1

package/dist/RefSubject/RefSubject.d.ts

@@ -0,0 +1,1057 @@
+/** @effect-diagnostics missingEffectError:skip-file */
+/** @effect-diagnostics missingEffectContext:skip-file */
+import type * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import type { Equivalence } from "effect/Equivalence";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import type { Error as FxError, Fx } from "../Fx/index.js";
+import type { UnionToTuple } from "../Fx/internal/UnionToTuple.js";
+import * as Subject from "../Subject/Subject.js";
+import * as Versioned from "../Versioned/Versioned.js";
+export declare const RefSubjectTypeId: unique symbol;
+export type RefSubjectTypeId = typeof RefSubjectTypeId;
+export declare const ComputedTypeId: unique symbol;
+export type ComputedTypeId = typeof ComputedTypeId;
+export declare const FilteredTypeId: unique symbol;
+export type FilteredTypeId = typeof FilteredTypeId;
+/**
+ * A `Computed` is a read-only view of a value that can change over time.
+ * It is an `Fx` that emits the current value and subsequent updates.
+ * It is also an `Effect` that samples the current value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // Create a RefSubject and derive a Computed from it
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Create a computed that doubles the count
+ *   const doubled = RefSubject.map(count, (n) => n * 2)
+ *
+ *   // Sample the computed value
+ *   const value = yield* doubled
+ *   console.log(value) // 0
+ *
+ *   // Update the source
+ *   yield* RefSubject.set(count, 5)
+ *
+ *   // The computed automatically reflects the change
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Computed<out A, out E = never, out R = never> extends Versioned.Versioned<R, E, A, E, R | Scope.Scope, A, E, R> {
+    readonly [ComputedTypeId]: ComputedTypeId;
+}
+export declare namespace Computed {
+    type Any = Computed<any, any, any> | Computed<never, any, any> | Computed<any, never, any> | Computed<never, never, any>;
+}
+/**
+ * A `Filtered` is a `Computed` that may not always have a value.
+ * It is essentially a `Computed<Option<A>>` with helper methods.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * // Create a RefSubject and filter it
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Get the first even number (filtered)
+ *   const firstEven = RefSubject.filterMap(
+ *     numbers,
+ *     (arr) => Option.fromNullable(arr.find((n) => n % 2 === 0))
+ *   )
+ *
+ *   // Try to get the value (may fail with NoSuchElementError)
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ *
+ *   // Or convert back to Option
+ *   const option = firstEven.asComputed()
+ *   const maybeValue = yield* option
+ *   console.log(Option.isSome(maybeValue)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Filtered<out A, out E = never, out R = never> extends Versioned.Versioned<R, E, A, E, R | Scope.Scope, A, E | Cause.NoSuchElementError, R> {
+    readonly [FilteredTypeId]: FilteredTypeId;
+    /**
+     * Converts the Filtered back to a Computed of Option.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Option } from "effect"
+     * import * as RefSubject from "@typed/fx/RefSubject"
+     *
+     * const program = Effect.gen(function* () {
+     *   const filtered = RefSubject.filterMap(
+     *     yield* RefSubject.make([1, 2, 3]),
+     *     (arr) => Option.fromNullable(arr.find((n) => n > 5))
+     *   )
+     *
+     *   // Convert to Computed<Option<number>>
+     *   const computed = filtered.asComputed()
+     *   const option = yield* computed
+     *   console.log(Option.isNone(option)) // true (no number > 5)
+     * })
+     * ```
+     */
+    asComputed(): Computed<Option.Option<A>, E, R>;
+}
+export declare namespace Filtered {
+    type Any = Filtered<any, any, any> | Filtered<never, any, any> | Filtered<any, never, any> | Filtered<never, never, any>;
+}
+/**
+ * Interface for basic RefSubject operations: get, set, delete.
+ * @since 1.0.0
+ * @category models
+ */
+export interface GetSetDelete<A, E = never, R = never> {
+    readonly get: Effect.Effect<A, E, R>;
+    readonly set: (a: A) => Effect.Effect<A, E, R>;
+    readonly delete: Effect.Effect<Option.Option<A>, E, R>;
+}
+/**
+ * A `RefSubject` is a mutable reference that can be observed as an Fx.
+ * It combines the capabilities of a `Ref` (get/set/update) with a `Subject` (subscribe).
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // Create a RefSubject with an initial value
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Get the current value
+ *   const current = yield* count
+ *   console.log(current) // 0
+ *
+ *   // Update the value
+ *   yield* RefSubject.set(count, 5)
+ *   const updated = yield* count
+ *   console.log(updated) // 5
+ *
+ *   // Use as an Fx to observe changes
+ *   yield* Fx.observe(
+ *     count,
+ *     (value) => Effect.sync(() => console.log("Count changed:", value))
+ *   )
+ *
+ *   // Increment
+ *   yield* RefSubject.increment(count)
+ *   // Output: "Count changed: 6"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface RefSubject<A, E = never, R = never> extends Computed<A, E, R>, Subject.Subject<A, E, R> {
+    readonly [RefSubjectTypeId]: RefSubjectTypeId;
+    /**
+     * Runs an effect that can modify the RefSubject transactionally.
+     * All operations within the transaction are atomic and serialized.
+     *
+     * @example
+     * ```ts
+     * import { Effect } from "effect"
+     * import * as RefSubject from "@typed/fx/RefSubject"
+     *
+     * const program = Effect.gen(function* () {
+     *   const balance = yield* RefSubject.make(100)
+     *
+     *   // Transfer money atomically
+     *   yield* balance.updates((ref) =>
+     *     Effect.gen(function* () {
+     *       const current = yield* ref.get
+     *       if (current >= 50) {
+     *         yield* ref.set(current - 50)
+     *         return "Transfer successful"
+     *       }
+     *       return "Insufficient funds"
+     *     })
+     *   )
+     * })
+     * ```
+     */
+    readonly updates: <B, E2, R2>(f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>) => Effect.Effect<B, E | E2, R | R2>;
+    /**
+     * Interrupts the RefSubject, stopping all subscriptions and cleaning up resources.
+     *
+     * @example
+     * ```ts
+     * import { Effect } from "effect"
+     * import * as RefSubject from "@typed/fx/RefSubject"
+     *
+     * const program = Effect.gen(function* () {
+     *   const ref = yield* RefSubject.make(0)
+     *
+     *   // Later, clean up
+     *   yield* ref.interrupt
+     * })
+     * ```
+     */
+    readonly interrupt: Effect.Effect<void, never, R>;
+}
+export declare namespace RefSubject {
+    type Any = RefSubject<any, any, any> | RefSubject<any, any> | RefSubject<any, never, any> | RefSubject<any>;
+    interface Service<Self, Id extends string, A, E> extends RefSubject<A, E, Self> {
+        readonly id: Id;
+        readonly service: ServiceMap.Service<Self, RefSubject<A, E>>;
+        readonly make: <R = never>(value: A | Effect.Effect<A, E, R> | Fx<A, E, R>, options?: RefSubjectOptions<A> & {
+            readonly skip?: number;
+            readonly take?: number;
+        }) => Layer.Layer<Self, never, Exclude<R, Scope.Scope>>;
+        readonly layer: <E2, R2>(make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>) => Layer.Layer<Self, E2, Exclude<R2, Scope.Scope>>;
+    }
+    interface Class<Self, Id extends string, A, E> extends RefSubject.Service<Self, Id, A, E> {
+        new (): RefSubject.Service<Self, Id, A, E>;
+    }
+}
+export declare const CurrentComputedBehavior: ServiceMap.Reference<"one" | "multiple">;
+export declare function makeComputed<R0, E0, A, E, R, E2, R2, C, E3, R3>(input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<C, E3, R3>): Computed<C, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
+export declare function makeFiltered<R0, E0, A, E, R, E2, R2, C, E3, R3>(input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>): Filtered<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3>;
+export interface RefSubjectOptions<A> {
+    readonly eq?: Equivalence<A>;
+}
+/**
+ * Creates a new `RefSubject` from a value, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // From a plain value
+ * const program1 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(42)
+ *   const value = yield* ref
+ *   console.log(value) // 42
+ * })
+ *
+ * // From an Effect
+ * const program2 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(
+ *     Effect.succeed("Hello")
+ *   )
+ *   const value = yield* ref
+ *   console.log(value) // "Hello"
+ * })
+ *
+ * // From an Fx (tracks the latest value)
+ * const program3 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(
+ *     Fx.fromIterable([1, 2, 3])
+ *   )
+ *   const value = yield* ref
+ *   console.log(value) // 3 (latest value)
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function make<A, E = never, R = never>(effect: A | Effect.Effect<A, E, R> | Stream.Stream<A, E, R> | Fx<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
+/**
+ * Creates a `RefSubject` from an `Effect`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromEffect(
+ *     Effect.succeed("Initial value")
+ *   )
+ *
+ *   const value = yield* ref
+ *   console.log(value) // "Initial value"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function fromEffect<A, E, R>(effect: Effect.Effect<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
+/**
+ * Creates a `RefSubject` from an `Fx`, tracking the latest emitted value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   // Create an Fx that emits multiple values
+ *   const numbers = Fx.fromIterable([1, 2, 3, 4, 5])
+ *
+ *   // Create a RefSubject that tracks the latest value
+ *   const ref = yield* RefSubject.fromFx(numbers)
+ *
+ *   // Get the latest value
+ *   const latest = yield* ref
+ *   console.log(latest) // 5
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function fromFx<A, E, R>(fx: Fx<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
+export declare function fromStream<A, E, R>(stream: Stream.Stream<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
+/**
+ * Creates a `RefSubject` from an `Option` value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const value = yield* ref
+ *   console.log(Option.isSome(value)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function fromOption<A>(option: Option.Option<A>, options?: RefSubjectOptions<Option.Option<A>>): Effect.Effect<RefSubject<Option.Option<A>>, never, Scope.Scope>;
+export declare function fromNullable<A>(value: A | null | undefined, options?: RefSubjectOptions<Option.Option<NonNullable<A>>>): Effect.Effect<RefSubject<Option.Option<NonNullable<A>>>, never, Scope.Scope>;
+/**
+ * Sets the value of a `RefSubject`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Set the value
+ *   yield* RefSubject.set(count, 10)
+ *   const value = yield* count
+ *   console.log(value) // 10
+ *
+ *   // Can also use pipe syntax
+ *   yield* count.pipe(RefSubject.set(20))
+ *   const newValue = yield* count
+ *   console.log(newValue) // 20
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const set: {
+    <A>(value: A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, a: A): Effect.Effect<A, E, R>;
+};
+/**
+ * Resets a `RefSubject` to its initial value, returning the previous value if it existed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   yield* RefSubject.set(count, 5)
+ *   const before = yield* count
+ *   console.log(before) // 5
+ *
+ *   // Reset to initial value
+ *   const previous = yield* RefSubject.reset(count)
+ *   console.log(Option.isSome(previous)) // true
+ *   console.log(previous.value) // 5
+ *
+ *   const after = yield* count
+ *   console.log(after) // 0
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function reset<A, E, R>(ref: RefSubject<A, E, R>): Effect.Effect<Option.Option<A>, E, R>;
+export { 
+/**
+ * Deletes the current value of a `RefSubject`, resetting it to its initial state.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(10)
+ *   yield* RefSubject.set(ref, 20)
+ *
+ *   // Delete the current value
+ *   const deleted = yield* RefSubject.delete(ref)
+ *   console.log(Option.isSome(deleted)) // true
+ *   console.log(deleted.value) // 20
+ *
+ *   // Value is reset to initial
+ *   const current = yield* ref
+ *   console.log(current) // 10
+ * })
+ * ```
+ *
+ * @since 1.20.0
+ * @category combinators
+ */
+reset as delete, };
+/**
+ * Updates a `RefSubject` using an `Effect`ful function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Update with an async operation
+ *   yield* RefSubject.updateEffect(count, (value) =>
+ *     Effect.succeed(value * 2)
+ *   )
+ *
+ *   const result = yield* count
+ *   console.log(result) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const updateEffect: {
+    <A, E2, R2>(f: (value: A) => Effect.Effect<A, E2, R2>): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<A, E2, R2>): Effect.Effect<A, E | E2, R | R2>;
+};
+/**
+ * Updates a `RefSubject` using a pure function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Increment by 1
+ *   yield* RefSubject.update(count, (n) => n + 1)
+ *   const value = yield* count
+ *   console.log(value) // 6
+ *
+ *   // Can also use pipe syntax
+ *   yield* count.pipe(RefSubject.update((n) => n * 2))
+ *   const doubled = yield* count
+ *   console.log(doubled) // 12
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const update: {
+    <A>(f: (value: A) => A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, f: (value: A) => A): Effect.Effect<A, E, R>;
+};
+/**
+ * Modifies a `RefSubject` using an `Effect`ful function that returns both a result and a new value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Get the old value and set a new one, returning the old value
+ *   const oldValue = yield* RefSubject.modifyEffect(count, (value) =>
+ *     Effect.succeed([value, value + 10] as const)
+ *   )
+ *
+ *   console.log(oldValue) // 5
+ *   const newValue = yield* count
+ *   console.log(newValue) // 15
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const modifyEffect: {
+    <A, B, E2, R2>(f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>): Effect.Effect<B, E | E2, R | R2>;
+};
+/**
+ * Modifies a `RefSubject` using a pure function that returns both a result and a new value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Get the old value and increment, returning the old value
+ *   const oldValue = yield* RefSubject.modify(count, (value) => [value, value + 1] as const)
+ *
+ *   console.log(oldValue) // 5
+ *   const newValue = yield* count
+ *   console.log(newValue) // 6
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const modify: {
+    <A, B>(f: (value: A) => readonly [B, A]): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E, R>;
+    <A, E, R, B>(ref: RefSubject<A, E, R>, f: (value: A) => readonly [B, A]): Effect.Effect<B, E, R>;
+};
+/**
+ * Checks if a value is a `RefSubject`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(42)
+ *   const isRef = RefSubject.isRefSubject(ref)
+ *   console.log(isRef) // true
+ *
+ *   const notRef = { value: 42 }
+ *   const isNotRef = RefSubject.isRefSubject(notRef)
+ *   console.log(isNotRef) // false
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category guards
+ */
+export declare function isRefSubject(value: any): value is RefSubject<any, any, any>;
+/**
+ * Runs an effect that can modify a `RefSubject` transactionally, with optional interrupt handling.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const balance = yield* RefSubject.make(100)
+ *
+ *   // Transfer money atomically with interrupt handling
+ *   yield* RefSubject.runUpdates(
+ *     balance,
+ *     (ref) =>
+ *       Effect.gen(function* () {
+ *         const current = yield* ref.get
+ *         if (current >= 50) {
+ *           yield* ref.set(current - 50)
+ *           return "Transfer successful"
+ *         }
+ *         return "Insufficient funds"
+ *       }),
+ *     {
+ *       onInterrupt: (value) => Effect.sync(() => console.log(`Interrupted at balance: ${value}`)),
+ *       value: "initial"
+ *     }
+ *   )
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const runUpdates: {
+    <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>, options?: {
+        readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+        readonly value?: "initial" | "current";
+    }): (ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
+    <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(ref: RefSubject<A, E, R>, f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>, options?: {
+        readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+        readonly value?: "initial" | "current";
+    } | undefined): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
+};
+/**
+ * Increments a numeric `RefSubject` by 1.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   yield* RefSubject.increment(count)
+ *   const value = yield* count
+ *   console.log(value) // 1
+ *
+ *   yield* RefSubject.increment(count)
+ *   const newValue = yield* count
+ *   console.log(newValue) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function increment<E, R>(ref: RefSubject<number, E, R>): Effect.Effect<number, E, R>;
+/**
+ * Decrements a numeric `RefSubject` by 1.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(10)
+ *
+ *   yield* RefSubject.decrement(count)
+ *   const value = yield* count
+ *   console.log(value) // 9
+ *
+ *   yield* RefSubject.decrement(count)
+ *   const newValue = yield* count
+ *   console.log(newValue) // 8
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function decrement<E, R>(ref: RefSubject<number, E, R>): Effect.Effect<number, E, R>;
+export declare function Service<Self, A, E = never>(): <const Id extends string>(id: Id) => RefSubject.Class<Self, Id, A, E>;
+/**
+ * Extract all values from an object using a Proxy.
+ * Allows accessing nested properties of a `Computed` or `Filtered` object/array as individual computed values.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const user = yield* RefSubject.make({ name: "Alice", age: 30 })
+ *
+ *   // Create a proxy to access nested properties
+ *   const proxied = RefSubject.proxy(user)
+ *
+ *   // Access individual properties as Computed values
+ *   const name = yield* proxied.name
+ *   console.log(name) // "Alice"
+ *
+ *   const age = yield* proxied.age
+ *   console.log(age) // 30
+ *
+ *   // Update the source
+ *   yield* RefSubject.set(user, { name: "Bob", age: 25 })
+ *
+ *   // Proxied values automatically update
+ *   const newName = yield* proxied.name
+ *   console.log(newName) // "Bob"
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export declare const proxy: {
+    <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(source: Computed<A, E, R>): {
+        readonly [K in keyof A]: Computed<A[K], E, R>;
+    };
+    <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(source: Filtered<A, E, R>): {
+        readonly [K in keyof A]: Filtered<A[K], E, R>;
+    };
+};
+export type Services<T> = T extends RefSubject<infer _A, infer _E, infer R> ? R : T extends Computed<infer _A, infer _E, infer R> ? R : T extends Filtered<infer _A, infer _E, infer R> ? R : never;
+export type Error<T> = T extends RefSubject<infer _A, infer E, infer _R> ? E : T extends Computed<infer _A, infer E, infer _R> ? E : T extends Filtered<infer _A, infer E, infer _R> ? E : never;
+export type Success<T> = T extends RefSubject<infer A, infer _E, infer _R> ? A : T extends Computed<infer A, infer _E, infer _R> ? A : T extends Filtered<infer A, infer _E, infer _R> ? A : never;
+export type Identifier<T> = T extends RefSubject.Service<infer R, infer _Id, infer _A, infer _E> ? R : never;
+/**
+ * Transforms a `RefSubject`, `Computed`, or `Filtered` using an `Effect`ful function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Transform with an async operation
+ *   const doubled = RefSubject.mapEffect(count, (n) =>
+ *     Effect.succeed(n * 2)
+ *   )
+ *
+ *   const value = yield* doubled
+ *   console.log(value) // 10
+ *
+ *   // Update source
+ *   yield* RefSubject.set(count, 7)
+ *
+ *   // Computed automatically updates
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 14
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const mapEffect: {
+    <T extends RefSubject.Any | Computed.Any | Filtered.Any, B, E2, R2>(f: (a: Success<T>) => Effect.Effect<B, E2, R2>): (ref: T) => T extends Filtered.Any ? Filtered<B, Error<T> | E2, Services<T> | R2> : Computed<B, Error<T> | E2, Services<T> | R2>;
+    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Computed<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(ref: Filtered<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Filtered<B, E | E2, R | R2>;
+    <R0, E0, A, E, R, E2, R2, C, E3, R3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<C, E3, R3>): Computed<C, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
+};
+/**
+ * Transforms a `RefSubject`, `Computed`, or `Filtered` using a pure function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Create a computed that doubles the count
+ *   const doubled = RefSubject.map(count, (n) => n * 2)
+ *
+ *   const value = yield* doubled
+ *   console.log(value) // 10
+ *
+ *   // Update source
+ *   yield* RefSubject.set(count, 7)
+ *
+ *   // Computed automatically updates
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 14
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const map: {
+    <T extends RefSubject.Any | Computed.Any | Filtered.Any, B>(f: (a: Success<T>) => B): (ref: T) => T extends Filtered.Any ? Filtered<B, Error<T>, Services<T>> : Computed<B, Error<T>, Services<T>>;
+    <A, E, R, B>(ref: RefSubject<A, E, R> | Computed<A, E, R>, f: (a: A) => B): Computed<B, E, R>;
+    <A, E, R, B>(filtered: Filtered<A, E, R>, f: (a: A) => B): Filtered<B, E, R>;
+    <R0, E0, A, E, R, B, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => B): Computed<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>> | Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
+};
+/**
+ * Filters and transforms a `RefSubject`, `Computed`, or `Filtered` using an `Effect`ful function that returns an `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Find the first even number
+ *   const firstEven = RefSubject.filterMapEffect(numbers, (arr) =>
+ *     Effect.succeed(Option.fromNullable(arr.find((n) => n % 2 === 0)))
+ *   )
+ *
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const filterMapEffect: {
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): {
+        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Filtered<B, E | E2, R | R2>;
+        <E, R>(ref: Filtered<A, E, R>): Filtered<B, E | E2, R | R2>;
+        <R0, E0, B, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): Filtered<B, E0 | E | E2, R0 | R2>;
+    };
+    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): Filtered<B, E | E2, R | R2>;
+    <R0, E0, A, E, R, B, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>): Filtered<B, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
+};
+/**
+ * Filters and transforms a `RefSubject`, `Computed`, or `Filtered` using a pure function that returns an `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Get the first even number
+ *   const firstEven = RefSubject.filterMap(numbers, (arr) =>
+ *     Option.fromNullable(arr.find((n) => n % 2 === 0))
+ *   )
+ *
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const filterMap: {
+    <A, B>(f: (a: A) => Option.Option<B>): {
+        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Filtered<B, E, R>;
+        <R0, E0, B, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Option.Option<B>): Filtered<B, E0 | E | E2, R0 | R2>;
+    };
+    <R0, E0, A, E, R, B, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Option.Option<B>): Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
+    <A, E, R, B>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Option.Option<B>): Filtered<B, E, R>;
+};
+/**
+ * Converts a `Computed` or `Filtered` of `Option<A>` into a `Filtered<A>`, filtering out `None` values.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const maybeValue = yield* RefSubject.make(Option.some(42))
+ *
+ *   // Compact the Option
+ *   const filtered = RefSubject.compact(maybeValue)
+ *
+ *   const value = yield* filtered
+ *   console.log(value) // 42
+ *
+ *   // If the Option becomes None, the Filtered will fail
+ *   yield* RefSubject.set(maybeValue, Option.none())
+ *   // yield* filtered would fail with NoSuchElementError
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const compact: {
+    <A, E, R>(ref: Computed<Option.Option<A>, E, R>): Filtered<A>;
+    <A, E, R>(ref: Filtered<Option.Option<A>, E, R>): Filtered<A>;
+    <R0, E0, A, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, Option.Option<A>, E, R, Option.Option<A>, E2, R2>): Filtered<A, E0 | E | Exclude<E, Cause.NoSuchElementError> | Exclude<E2, Cause.NoSuchElementError>, R0 | R2 | Exclude<R, Scope.Scope>>;
+};
+/**
+ * Returns a `Computed` that yields the value inside the `Option`, or the fallback when `None`.
+ * Works with `Computed<Option<A>>` (e.g. from `fromOption` / `fromNullable`) and with `Filtered<A>`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const withDefault = RefSubject.getOrElse(ref, () => 0)
+ *   expect(yield* withDefault).toBe(42)
+ *
+ *   const empty = yield* RefSubject.fromNullable(null)
+ *   const fallback = RefSubject.getOrElse(empty, () => 99)
+ *   expect(yield* fallback).toBe(99)
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const getOrElse: {
+    <A>(fallback: () => A): <E, R>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>) => Computed<A, E, R>;
+    <A, E, R>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>, fallback: () => A): Computed<A, E, R>;
+};
+export declare const slice: {
+    (skip: number, take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, skip: number, take: number): RefSubject<A, E, R>;
+};
+/**
+ * Transforms a `RefSubject` invariantly using bidirectional mapping functions.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Transform to string and back
+ *   const countStr = RefSubject.transform(
+ *     count,
+ *     (n) => n.toString(),
+ *     (s) => parseInt(s, 10)
+ *   )
+ *
+ *   const value = yield* countStr
+ *   console.log(value) // "5"
+ *
+ *   // Set using the transformed type
+ *   yield* RefSubject.set(countStr, "10")
+ *
+ *   // Original reflects the change
+ *   const original = yield* count
+ *   console.log(original) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const transform: {
+    <A, B>(toB: (a: A) => B, toA: (b: B) => A): <E, R>(ref: RefSubject<A, E, R>) => RefSubject<B, E, R>;
+    <A, E, R, B>(ref: RefSubject<A, E, R>, toB: (a: A) => B, toA: (b: B) => A): RefSubject<B, E, R>;
+};
+type RefKind = "r" | "c" | "f";
+type StructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = {
+    c: [ComputedStructFrom<Refs>] extends [Computed<infer A, infer E, infer R>] ? Computed<A, E, R> : never;
+    f: [FilteredStructFrom<Refs>] extends [Filtered<infer A, infer E, infer R>] ? Filtered<A, E, R> : never;
+    r: [RefSubjectStructFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>] ? RefSubject<A, E, R> : never;
+}[GetStructKind<Refs>];
+type GetStructKind<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = MergeKinds<UnionToTuple<{
+    [K in keyof Refs]: MatchKind<Refs[K]>;
+}[keyof Refs]>>;
+type Ref = RefSubject.Any | Computed.Any | Filtered.Any;
+type MatchKind<T extends Ref> = [T] extends [Filtered.Any] ? "f" : [T] extends [RefSubject.Any] ? "r" : "c";
+type MergeKind<A extends RefKind, B extends RefKind> = A extends "f" ? A : B extends "f" ? B : A extends "r" ? B : B extends "r" ? A : "c";
+type MergeKinds<Kinds extends ReadonlyArray<any>> = Kinds extends readonly [
+    infer Head extends RefKind,
+    ...infer Tail extends ReadonlyArray<RefKind>
+] ? MergeKind<Head, MergeKinds<Tail>> : "r";
+type FilteredStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Filtered<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, FxError<Refs[keyof Refs]>, Effect.Services<Refs[keyof Refs]>>;
+type ComputedStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Computed<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, Effect.Error<Refs[keyof Refs]>, Effect.Services<Refs[keyof Refs]>>;
+type RefSubjectStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = RefSubject<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, Effect.Error<Refs[keyof Refs]>, Effect.Services<Refs[keyof Refs]>>;
+type TupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = {
+    c: [ComputedTupleFrom<Refs>] extends [Computed<infer A, infer E, infer R>] ? Computed<A, E, R> : never;
+    f: [FilteredTupleFrom<Refs>] extends [Filtered<infer A, infer E, infer R>] ? Filtered<A, E, R> : never;
+    r: [RefSubjectTupleFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>] ? RefSubject<A, E, R> : never;
+}[GetTupleKind<Refs>];
+type GetTupleKind<Refs extends ReadonlyArray<Ref>, Kind extends RefKind = "r"> = Refs extends readonly [infer Head extends Ref, ...infer Tail extends ReadonlyArray<Ref>] ? GetTupleKind<Tail, MergeKind<Kind, MatchKind<Head>>> : Kind;
+type FilteredTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Filtered<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, FxError<Refs[number]>, Effect.Services<Refs[number]>>;
+type ComputedTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Computed<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, Effect.Error<Refs[number]>, Effect.Services<Refs[number]>>;
+type RefSubjectTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = RefSubject<{
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+}, Effect.Error<Refs[number]>, Effect.Services<Refs[number]>>;
+/**
+ * Combines multiple `RefSubject`, `Computed`, or `Filtered` instances into a single struct.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const firstName = yield* RefSubject.make("Alice")
+ *   const lastName = yield* RefSubject.make("Smith")
+ *   const age = yield* RefSubject.make(30)
+ *
+ *   // Combine into a struct
+ *   const person = RefSubject.struct({
+ *     firstName,
+ *     lastName,
+ *     age
+ *   })
+ *
+ *   const fullPerson = yield* person
+ *   console.log(fullPerson) // { firstName: "Alice", lastName: "Smith", age: 30 }
+ *
+ *   // Update one field
+ *   yield* RefSubject.set(firstName, "Bob")
+ *
+ *   // Struct automatically updates
+ *   const updated = yield* person
+ *   console.log(updated.firstName) // "Bob"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function struct<const Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>>(refs: Refs): StructFrom<Refs>;
+/**
+ * Combines multiple `RefSubject`, `Computed`, or `Filtered` instances into a single tuple.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const x = yield* RefSubject.make(10)
+ *   const y = yield* RefSubject.make(20)
+ *   const z = yield* RefSubject.make(30)
+ *
+ *   // Combine into a tuple
+ *   const point = RefSubject.tuple([x, y, z])
+ *
+ *   const coords = yield* point
+ *   console.log(coords) // [10, 20, 30]
+ *
+ *   // Update one value
+ *   yield* RefSubject.set(x, 15)
+ *
+ *   // Tuple automatically updates
+ *   const updated = yield* point
+ *   console.log(updated) // [15, 20, 30]
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare function tuple<const Refs extends ReadonlyArray<Ref>>(refs: Refs): TupleFrom<Refs>;
+export declare function computedFromService<R, A, E, R2>(effect: Effect.Effect<Computed<A, E, R2>, never, R>): Computed<A, E, R | R2>;
+export declare function filteredFromService<R, A, E, R2>(effect: Effect.Effect<Filtered<A, E, R2>, never, R>): Filtered<A, E, R | R2>;
+//# sourceMappingURL=RefSubject.d.ts.map