@typed/fx 1.19.0 → 1.20.0

package/dist/dts/RefSubject.d.ts

@@ -1,282 +1,491 @@
 /**
- * A RefSubject is the core abstraction for keeping state and subscribing to its
- * changes over time.
- *
- * @since 1.18.0
+ * A RefSubject is a Subject that can be used to read and write a value.
+ * @since 1.20.0
  */
-import type { Schema } from "@effect/schema";
 import * as C from "@typed/context";
-import type { Stream, SubscriptionRef } from "effect";
-import { Cause } from "effect";
+import type { Equivalence, FiberId, Runtime } from "effect";
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
-import type { Equivalence } from "effect/Equivalence";
-import type * as Layer from "effect/Layer";
+import * as ExecutionStrategy from "effect/ExecutionStrategy";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import type * as Scope from "effect/Scope";
-import { Computed } from "./Computed.js";
-import { Filtered } from "./Filtered.js";
-import type * as Fx from "./Fx.js";
-import type * as Subject from "./Subject.js";
-import { RefSubjectTypeId } from "./TypeId.js";
-/**
- * A RefSubject is a Subject that has a current value that can be read and updated.
- * @since 1.18.0
- * @category models
+import * as Scope from "effect/Scope";
+import type { Fx } from "./Fx.js";
+import type { UnionToTuple } from "./internal/UnionToTuple.js";
+import * as Subject from "./Subject.js";
+import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "./TypeId.js";
+import * as Versioned from "./Versioned.js";
+/**
+ * A Computed is essentially a readonly RefSubject.
+ * @since 1.20.0
  */
-export interface RefSubject<R, in out E, in out A> extends Computed<R, E, A>, Subject.Subject<R, E, A> {
-    readonly [RefSubjectTypeId]: RefSubjectTypeId;
-    /**
-     * Get the current value of this RefSubject. If the RefSubject has not been initialized
-     * then the initial value will be computed and returned. Concurrent calls to `get` will
-     * only compute the initial value once.
-     * @since 1.18.0
-     */
-    readonly get: Effect.Effect<R, E, A>;
-    /**
-     * Set the current value of this RefSubject.
-     * @since 1.18.0
-     */
-    readonly set: (a: A) => Effect.Effect<R, never, A>;
-    /**
-     * Modify the current value of this RefSubject using the provided function.
-     * @since 1.18.0
-     */
-    readonly update: (f: (a: A) => A) => Effect.Effect<R, E, A>;
-    /**
-     * Modify the current value of this RefSubject and compute a new value.
-     * @since 1.18.0
-     */
-    readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<R, E, B>;
-    /**
-     * Delete the current value of this RefSubject. If it was not initialized the Option.none will be returned.
-     * Otherwise the current value will be returned as an Option.some and the RefSubject will be uninitialized.
-     * If there are existing subscribers to this RefSubject then the RefSubject will be re-initialized.
-     * @since 1.18.0
-     */
-    readonly delete: Effect.Effect<R, never, Option.Option<A>>;
+export interface Computed<out R, out E, out A> extends Versioned.Versioned<R, E, R | Scope.Scope, E, A, R, E, A> {
+    readonly [ComputedTypeId]: ComputedTypeId;
+}
+/**
+ * @since 1.20.0
+ */
+export declare namespace Computed {
     /**
-     * Modify the current value of this RefSubject and compute a new value using the provided effectful function.
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    readonly modifyEffect: <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => Effect.Effect<R | R2, E | E2, B>;
+    type Any = Computed<any, any, any> | Computed<never, any, any> | Computed<any, never, any> | Computed<never, never, any>;
+}
+/**
+ * A Filtered is essentially a readonly RefSubject that may have its values filtered out.
+ * @since 1.20.0
+ */
+export interface Filtered<out R, out E, out A> extends Versioned.Versioned<R, E, R | Scope.Scope, E, A, R, E | Cause.NoSuchElementException, A> {
+    readonly [FilteredTypeId]: FilteredTypeId;
     /**
-     * Modify the current value of this RefSubject using the provided effectful function.
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    readonly updateEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) => Effect.Effect<R | R2, E | E2, A>;
+    asComputed(): Computed<R, E, Option.Option<A>>;
+}
+/**
+ * @since 1.20.0
+ */
+export declare namespace Filtered {
     /**
-     * Modify the current value of this RefSubject and compute a new value using the provided effectful function.
-     * The key difference is it will allow running a workflow and setting the value multiple times. Optionally,
-     * another function can be provided to change the value
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    readonly runUpdate: <R2, E2, B, R3 = never, E3 = never>(updates: (get: RefSubject<R, E, A>["get"], set: RefSubject<R, E, A>["set"]) => Effect.Effect<R2, E2, B>, onInterrupt?: (a: A) => Effect.Effect<R3, E3, A>) => Effect.Effect<R | R2 | R3, E | E2 | E3, B>;
+    type Any = Filtered<any, any, any> | Filtered<never, any, any> | Filtered<any, never, any> | Filtered<never, never, any>;
+}
+/**
+ * A RefSubject is a Subject that can be used to read and write a value.
+ * @since 1.20.0
+ */
+export interface RefSubject<out R, in out E, in out A> extends Computed<R, E, A>, Subject.Subject<R, E, A> {
+    readonly [RefSubjectTypeId]: RefSubjectTypeId;
     /**
-     * Interrupt the current Fibers.
+     * @since 1.20.0
      */
-    readonly interrupt: Effect.Effect<R, never, void>;
+    readonly runUpdates: <R2, E2, B>(f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>) => Effect.Effect<R | R2, E2, B>;
 }
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export declare namespace RefSubject {
     /**
-     * @since 1.18.0
+     * @since 1.20.0
      */
     type Any = RefSubject<any, any, any> | RefSubject<never, any, any> | RefSubject<any, never, any> | RefSubject<never, never, any>;
     /**
-     * A Contextual wrapper around a RefSubject
-     * @since 1.18.0
-     * @category models
+     * @since 1.20.0
      */
     interface Tagged<I, E, A> extends RefSubject<I, E, A> {
-        readonly tag: C.Tagged<I, RefSubject<never, E, A>>;
-        /**
-         * Make a layer initializing a RefSubject
-         * @since 1.18.0
-         */
-        readonly make: <R = never>(fx: Exclude<Fx.FxInput<R, E, A>, Iterable<A>>, eq?: Equivalence<A>) => Layer.Layer<R, never, I>;
         /**
-         * Make a layer initializing a RefSubject
-         * @since 1.18.0
+         * @since 1.20.0
          */
-        readonly of: (value: A, eq?: Equivalence<A>) => Layer.Layer<never, never, I>;
-        /**
-         * Provide an implementation of this RefSubject
-         * @since 1.18.0
-         */
-        readonly provide: <R2>(fx: Fx.FxInput<R2, E, A>, eq?: Equivalence<A>) => <R3, E3, C>(effect: Effect.Effect<R3, E3, C>) => Effect.Effect<R2 | Exclude<R3, I> | Scope.Scope, E | E3, C>;
+        readonly tag: C.Tagged<I, RefSubject<never, E, A>>;
         /**
-         * Provide an implementation of this RefSubject
-         * @since 1.18.0
+         * @since 1.20.0
          */
-        readonly provideFx: <R2>(fx: Fx.FxInput<R2, E, A>, eq?: Equivalence<A>) => <R3, E3, C>(effect: Fx.Fx<R3, E3, C>) => Fx.Fx<R2 | Exclude<R3, I> | Scope.Scope, E | E3, C>;
+        readonly make: <R>(fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>) => Layer.Layer<R, never, I>;
     }
     /**
      * A Contextual wrapper around a RefSubject
      * @since 1.18.0
      * @category models
      */
-    interface Derived<R0, R, E, A> extends RefSubject<R, E, A> {
-        readonly persist: Effect.Effect<R0, never, void>;
+    interface Derived<R, E, A> extends RefSubject<R, E, A> {
+        readonly persist: Effect.Effect<R, never, void>;
     }
+}
+/**
+ * @since 1.20.0
+ */
+export type Context<T> = Fx.Context<T>;
+/**
+ * @since 1.20.0
+ */
+export type Error<T> = Fx.Error<T>;
+/**
+ * @since 1.20.0
+ */
+export type Success<T> = Fx.Success<T>;
+/**
+ * @since 1.20.0
+ */
+export interface RefSubjectOptions<A> {
+    readonly eq?: Equivalence.Equivalence<A>;
+    readonly replay?: number;
+    readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy;
+}
+/**
+ * @since 1.20.0
+ */
+export declare function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
+/**
+ * @since 1.20.0
+ */
+export declare function fromFx<R, E, A>(fx: Fx<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
+/**
+ * @since 1.20.0
+ */
+export declare function fromRefSubject<R, E, A>(ref: RefSubject<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject.Derived<never, E, A>>;
+/**
+ * @since 1.20.0
+ */
+export declare const make: {
+    <R, E, A>(ref: RefSubject<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject.Derived<never, E, A>>;
+    <R, E, A>(fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
+    <R, E, A>(fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A> | RefSubject<R, E, A>, options?: RefSubjectOptions<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A> | RefSubject.Derived<never, E, A>>;
+};
+/**
+ * @since 1.20.0
+ */
+export declare function of<A, E = never>(a: A, options?: RefSubjectOptions<A>): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>>;
+/**
+ * @since 1.20.0
+ */
+export declare function unsafeMake<E, A>(params: {
+    readonly id: FiberId.FiberId;
+    readonly initial: Effect.Effect<never, E, A>;
+    readonly options?: RefSubjectOptions<A> | undefined;
+    readonly scope: Scope.CloseableScope;
+    readonly initialValue?: A;
+}): Effect.Effect<never, never, RefSubject<never, E, A>>;
+/**
+ * @since 1.20.0
+ */
+export declare const set: {
+    <A>(value: A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A>, a: A): Effect.Effect<R, E, A>;
+};
+/**
+ * @since 1.20.0
+ */
+export declare function reset<R, E, A>(ref: RefSubject<R, E, A>): Effect.Effect<R, E, Option.Option<A>>;
+/**
+ * @since 1.20.0
+ */
+export { 
+/**
+ * @since 1.20.0
+ */
+reset as delete };
+/**
+ * @since 1.20.0
+ */
+export interface GetSetDelete<R, E, A> {
     /**
-     * Extract the Identifier from a RefSubject
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    type Context<T> = T extends RefSubject<infer I, infer _, infer __> ? I : never;
+    readonly get: Effect.Effect<R, E, A>;
     /**
-     * Extract the Error from a RefSubject
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    type Error<T> = T extends RefSubject<infer _, infer E, infer __> ? E : never;
+    readonly set: (a: A) => Effect.Effect<R, never, A>;
     /**
-     * Extract the State from a RefSubject
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    type Success<T> = T extends RefSubject<infer _, infer __, infer S> ? S : never;
+    readonly delete: Effect.Effect<R, E, Option.Option<A>>;
 }
 /**
- * Extract the Identifier from a RefSubject
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type Context<T> = RefSubject.Context<T>;
+export declare const updateEffect: {
+    <A, R2, E2>(f: (value: A) => Effect.Effect<R2, E2, A>): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R | R2, E | E2, A>;
+    <R, E, A, R2, E2>(ref: RefSubject<R, E, A>, f: (value: A) => Effect.Effect<R2, E2, A>): Effect.Effect<R | R2, E | E2, A>;
+};
 /**
- * Extract the Error from a RefSubject
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type Error<T> = RefSubject.Error<T>;
+export declare const update: {
+    <A>(f: (value: A) => A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A>, f: (value: A) => A): Effect.Effect<R, E, A>;
+};
 /**
- * Extract the State from a RefSubject
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type Success<T> = RefSubject.Success<T>;
+export declare const modifyEffect: {
+    <A, R2, E2, B>(f: (value: A) => Effect.Effect<R2, E2, readonly [B, A]>): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R | R2, E | E2, B>;
+    <R, E, A, R2, E2, B>(ref: RefSubject<R, E, A>, f: (value: A) => Effect.Effect<R2, E2, readonly [B, A]>): Effect.Effect<R | R2, E | E2, B>;
+};
 /**
- * Construct a RefSubject with a lazily initialized value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function fromEffect<R, E, A>(initial: Effect.Effect<R, E, A>, eq?: Equivalence<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
+export declare const modify: {
+    <A, B>(f: (value: A) => readonly [B, A]): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, B>;
+    <R, E, A, B>(ref: RefSubject<R, E, A>, f: (value: A) => readonly [B, A]): Effect.Effect<R, E, B>;
+};
 /**
- * Construct a RefSubject from a synchronous value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function of<A, E = never>(initial: A, eq?: Equivalence<A>): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>>;
+export declare const runUpdates: {
+    <R, E, A, R2, E2, B, R3 = never, E3 = never, C = never>(f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>, options?: {
+        readonly onInterrupt: (value: A) => Effect.Effect<R3, E3, C>;
+        readonly value?: "initial" | "current";
+    } | undefined): (ref: RefSubject<R, E, A>) => Effect.Effect<R | R2 | R3, E | E2 | E3, B>;
+    <R, E, A, R2, E2, B, R3 = never, E3 = never, C = never>(ref: RefSubject<R, E, A>, f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>, options?: {
+        readonly onInterrupt: (value: A) => Effect.Effect<R3, E3, C>;
+        readonly value?: "initial" | "current";
+    } | undefined): Effect.Effect<R | R2 | R3, E | E2 | E3, B>;
+};
 /**
- * Construct a RefSubject from a synchronous value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function sync<A, E = never>(initial: () => A, eq?: Equivalence<A>): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>>;
+export declare const mapEffect: {
+    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): {
+        <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Computed<R | R2, E | E2, B>;
+        <R, E>(ref: Filtered<R, E, A>): Filtered<R | R2, E | E2, B>;
+        <R0, E0, R, E, R2, E2, C>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Effect.Effect<R2, E2, C>): Computed<R0 | R2, E0 | E | E2, C>;
+    };
+    <R, E, A, R2, E2, B>(ref: RefSubject<R, E, A> | Computed<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Computed<R | R2, E | E2, B>;
+    <R, E, A, R2, E2, B>(ref: Filtered<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Filtered<R | R2, E | E2, B>;
+    <R0, E0, R, E, A, R2, E2, R3, E3, C>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Effect.Effect<R3, E3, C>): Computed<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, C>;
+};
 /**
- * Construct a RefSubject from any Fx value.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function make<R, E, A>(fx: Effect.Effect<R, E, A>, eq?: Equivalence<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
-export declare function make<R, E, A>(fx: Fx.FxInput<R, E, A>, eq?: Equivalence<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>;
+export declare const map: {
+    <A, B>(f: (a: A) => B): {
+        <R, E>(ref: RefSubject<R, E, A>): Computed<R, E, B>;
+        <R, E>(ref: Computed<R, E, A>): Computed<R, E, B>;
+        <R, E>(ref: Filtered<R, E, A>): Filtered<R, E, B>;
+        <R0, E0, R, E, R2, E2>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => B): Computed<R0 | R2, E0 | E | E2, B>;
+    };
+    <R, E, A, B>(ref: RefSubject<R, E, A> | Computed<R, E, A>, f: (a: A) => B): Computed<R, E, B>;
+    <R, E, A, B>(filtered: Filtered<R, E, A>, f: (a: A) => B): Filtered<R, E, B>;
+    <R0, E0, R, E, A, R2, E2, B>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => B): Computed<R0 | R2 | Exclude<R, Scope.Scope>, E0 | E | E2, B> | Filtered<R0 | R2 | Exclude<R, Scope.Scope>, E0 | E | E2, B>;
+};
 /**
- * Create a contextual wrapper around a RefSubject while maintaing the full API of
- * a Ref Subject.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function tagged<A>(defaultEq?: Equivalence<A>): {
-    <const I extends C.IdentifierConstructor<any>>(identifier: (id: typeof C.id) => I): RefSubject.Tagged<C.IdentifierOf<I>, never, A>;
-    <const I>(identifier: I | string): RefSubject.Tagged<C.IdentifierOf<I>, never, A>;
+export declare const filterMapEffect: {
+    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): {
+        <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Filtered<R | R2, E | E2, B>;
+        <R, E>(ref: Filtered<R, E, A>): Filtered<R | R2, E | E2, B>;
+        <R0, E0, R, E, R2, E2, B>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Filtered<R0 | R2, E0 | E | E2, B>;
+    };
+    <R, E, A, R2, E2, B>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Filtered<R | R2, E | E2, B>;
+    <R0, E0, R, E, A, R2, E2, B, R3, E3>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Effect.Effect<R3, E3, Option.Option<B>>): Filtered<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, B>;
 };
-export declare function tagged<E, A>(defaultEq?: Equivalence<A>): {
-    <const I extends C.IdentifierConstructor<any>>(identifier: (id: typeof C.id) => I): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
-    <const I>(identifier: I | string): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
+/**
+ * @since 1.20.0
+ */
+export declare const filterMap: {
+    <A, B>(f: (a: A) => Option.Option<B>): {
+        <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>): Filtered<R, E, B>;
+        <R0, E0, R, E, R2, E2, B>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Option.Option<B>): Filtered<R0 | R2, E0 | E | E2, B>;
+    };
+    <R0, E0, R, E, A, R2, E2, B>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Option.Option<B>): Filtered<R0 | R2 | Exclude<R, Scope.Scope>, E0 | E | E2, B>;
+    <R, E, A, B>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>, f: (a: A) => Option.Option<B>): Filtered<R, E, B>;
 };
 /**
- * Construct a RefSubject from any Fx value.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function makeWithExtension<R, E, A, B>(fx: Effect.Effect<R, E, A>, f: (ref: RefSubject<never, E, A>) => B, eq?: Equivalence<A>): Effect.Effect<R, never, RefSubject<never, E, A> & B>;
-export declare function makeWithExtension<R, E, A, B>(fx: Fx.FxInput<R, E, A>, f: (ref: RefSubject<never, E, A>) => B, eq?: Equivalence<A>): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A> & B>;
+export declare const compact: {
+    <R, E, A>(ref: RefSubject<R, E, Option.Option<A>> | Computed<R, E, Option.Option<A>>): Filtered<R, E, A>;
+    <R, E, A>(ref: Filtered<R, E, Option.Option<A>>): Filtered<R, E, A>;
+    <R0, E0, R, E, A, R2, E2>(versioned: Versioned.Versioned<R0, E0, R, E, Option.Option<A>, R2, E2, Option.Option<A>>): Filtered<R0 | R2 | Exclude<R, Scope.Scope>, E0 | E | Exclude<E, Cause.NoSuchElementException> | Exclude<E2, Cause.NoSuchElementException>, A>;
+};
 /**
- * Construct a RefSubject with an initial value and the specified subject.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const unsafeMake: <R, E, A>(initial: Effect.Effect<R, E, A>, subject: Subject.Subject<R, E, A>, eq?: Equivalence<A>) => RefSubject<R, E, A>;
+export declare const filterEffect: {
+    <R, E, A, R2, E2>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Filtered<R | R2, E | E2, A>;
+    <R0, E0, R, E, A, R2, E2, R3, E3>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => Effect.Effect<R3, E3, boolean>): Filtered<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, A>;
+};
 /**
- * Flatten an RefSubject of an Option into a Filtered.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
+ */
+export declare const filter: {
+    <A>(f: (a: A) => boolean): {
+        <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>): Filtered<R, E, A>;
+        <R0, E0, R, E, R2, E2>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => boolean): Filtered<R0 | R2, E0 | E | E2, A>;
+    };
+    <R, E, A>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>, f: (a: A) => boolean): Filtered<R, E, A>;
+    <R0, E0, R, E, A, R2, E2, R3, E3>(versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>, f: (a: A) => boolean): Filtered<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, A>;
+};
+/**
+ * @since 1.20.0
  */
-export declare const compact: <R, E, A>(refSubject: RefSubject<R, E, Option.Option<A>>) => Filtered<R, E, A>;
+export declare const skipRepeatsWith: {
+    <A>(eq: Equivalence.Equivalence<A>): {
+        <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Computed<R, E, A>;
+        <R, E>(ref: Filtered<R, E, A>): Filtered<R, E, A>;
+    };
+    <R, E, A>(ref: RefSubject<R, E, A> | Computed<R, E, A>, eq: Equivalence.Equivalence<A>): Computed<R, E, A>;
+    <R, E, A>(ref: Filtered<R, E, A>, eq: Equivalence.Equivalence<A>): Filtered<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>, eq: Equivalence.Equivalence<A>): Computed<R, E, A> | Filtered<R, E, A>;
+};
 /**
- * Split a RefSubject's into 2 Filtered values that track its errors and
- * success values separately.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const split: <R, E, A>(refSubject: RefSubject<R, E, A>) => readonly [Filtered<R, never, E>, Filtered<R, never, A>];
+export declare function skipRepeats<R, E, A>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Computed<R, E, A>;
+export declare function skipRepeats<R, E, A>(ref: Filtered<R, E, A>): Filtered<R, E, A>;
+export declare function skipRepeats<R, E, A>(ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>): Computed<R, E, A> | Filtered<R, E, A>;
 /**
- * MakeRefSubject is a RefSubject factory function dervied from a Schema.
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export declare function transform<R, E, A, B>(ref: RefSubject<R, E, A>, from: (a: A) => B, to: (b: B) => A): RefSubject<R, E, B>;
+/**
+ * @since 1.20.0
+ */
+export declare function transformOrFail<R, E, R2, E2, A, R3, E3, B>(ref: RefSubject<R, E, A>, from: (a: A) => Effect.Effect<R2, E2, B>, to: (b: B) => Effect.Effect<R3, E3, A>): RefSubject<R | R2 | R3, E | E2 | E3, B>;
+/**
+ * @since 1.20.0
+ */
+export declare function tuple<const Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>>(refs: Refs): TupleFrom<Refs>;
+type RefKind = "r" | "c" | "f";
+/**
+ * @since 1.20.0
+ */
+export type TupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = {
+    "c": [ComputedTupleFrom<Refs>] extends [Computed<infer R, infer E, infer A>] ? Computed<R, E, A> : never;
+    "f": [FilteredTupleFrom<Refs>] extends [Filtered<infer R, infer E, infer A>] ? Filtered<R, E, A> : never;
+    "r": [RefSubjectTupleFrom<Refs>] extends [RefSubject<infer R, infer E, infer A>] ? RefSubject<R, E, A> : never;
+}[GetTupleKind<Refs>];
+type Ref = RefSubject.Any | Computed.Any | Filtered.Any;
+/**
+ * @since 1.20.0
+ */
+export 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;
+/**
+ * @since 1.20.0
+ */
+export 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 FilteredTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Filtered<Effect.Effect.Context<Refs[number]>, Fx.Error<Refs[number]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+type ComputedTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Computed<Effect.Effect.Context<Refs[number]>, Effect.Effect.Error<Refs[number]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+type RefSubjectTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = RefSubject<Effect.Effect.Context<Refs[number]>, Effect.Effect.Error<Refs[number]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+/**
+ * @since 1.20.0
  */
-export type MakeRefSubject<O> = {
-    <R, E>(input: RefSubject<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToDerived<R, E, O>>;
-    <R, E>(input: Effect.Effect<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>;
-    <R, E>(input: Stream.Stream<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>;
-    <R, E>(input: Fx.Fx<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>;
-    <E>(input: Cause.Cause<E>, eq?: Equivalence<O>): Effect.Effect<Scope.Scope, never, ToRefSubject<E, O>>;
-    <R, E>(input: Fx.FxInput<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>;
+export declare function struct<const Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>>(refs: Refs): StructFrom<Refs>;
+type StructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = {
+    "c": [ComputedStructFrom<Refs>] extends [Computed<infer R, infer E, infer A>] ? Computed<R, E, A> : never;
+    "f": [FilteredStructFrom<Refs>] extends [Filtered<infer R, infer E, infer A>] ? Filtered<R, E, A> : never;
+    "r": [RefSubjectStructFrom<Refs>] extends [RefSubject<infer R, infer E, infer A>] ? RefSubject<R, E, A> : never;
+}[GetStructKind<Refs>];
+/**
+ * @since 1.20.0
+ */
+export 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 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<Effect.Effect.Context<Refs[keyof Refs]>, Fx.Error<Refs[keyof Refs]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+type ComputedStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Computed<Effect.Effect.Context<Refs[keyof Refs]>, Effect.Effect.Error<Refs[keyof Refs]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+type RefSubjectStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = RefSubject<Effect.Effect.Context<Refs[keyof Refs]>, Effect.Effect.Error<Refs[keyof Refs]>, {
+    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
+}>;
+/**
+ * @since 1.20.0
+ */
+export declare function tagged<E, A>(replay?: number): {
+    <const I extends C.IdentifierFactory<any>>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
+    <const I>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
 };
 /**
- * Converts an error `E` and an output `O` into a RefSubject or a Record of RefSubjects if
- * the ouput value is a Record as well.
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type ToRefSubject<E, O> = O extends Readonly<Record<PropertyKey, any>> ? {
-    readonly [K in keyof O]: ToRefSubject<E, O[K]>;
-} : RefSubject<never, E, O>;
+export declare function fromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => RefSubject<R, E, A>): RefSubject<I | R, E, A>;
 /**
- * Converts an error `E` and an output `O` into a RefSubject or a Record of RefSubjects if
- * the ouput value is a Record as well.
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export declare function isRefSubject<R, E, A>(u: unknown): u is RefSubject<R, E, A>;
+export declare function isRefSubject(u: unknown): u is RefSubject.Any;
+/**
+ * @since 1.20.0
+ */
+export declare function isComputed<R, E, A>(u: unknown): u is Computed<R, E, A>;
+export declare function isComputed(u: unknown): u is Computed.Any;
+/**
+ * @since 1.20.0
+ */
+export declare function isFiltered<R, E, A>(u: unknown): u is Filtered<R, E, A>;
+export declare function isFiltered(u: unknown): u is Filtered.Any;
+/**
+ * @since 1.20.0
+ */
+export declare function isDerived<R, E, A>(u: unknown): u is RefSubject.Derived<R, E, A>;
+export declare function isDerived(u: unknown): u is RefSubject.Derived<unknown, unknown, unknown>;
+/**
+ * @since 1.20.0
+ */
+export declare function computedFromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => Computed<R, E, A>): Computed<I | R, E, A>;
+/**
+ * @since 1.20.0
+ */
+export declare function filteredFromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => Filtered<R, E, A>): Filtered<I | R, E, A>;
+/**
+ * @since 1.20.0
  */
-export type ToDerived<R, E, O> = ToRefSubject<E, O> & {
-    readonly persist: Effect.Effect<R, E, O>;
+export declare const provide: {
+    <S>(context: C.Context<S> | Runtime.Runtime<S>): {
+        <R, E, A>(filtered: Filtered<R, E, A>): Filtered<Exclude<R, S>, E, A>;
+        <R, E, A>(computed: Computed<R, E, A>): Computed<Exclude<R, S>, E, A>;
+        <R, E, A>(ref: RefSubject<R, E, A>): RefSubject<Exclude<R, S>, E, A>;
+    };
+    <R2, S>(layer: Layer.Layer<R2, never, S>): {
+        <R, E, A>(filtered: Filtered<R, E, A>): Filtered<Exclude<R, S> | R2, E, A>;
+        <R, E, A>(computed: Computed<R, E, A>): Computed<Exclude<R, S> | R2, E, A>;
+        <R, E, A>(ref: RefSubject<R, E, A>): RefSubject<Exclude<R, S> | R2, E, A>;
+    };
+    <R, E, A, S>(filtered: Filtered<R, E, A>, context: C.Context<S> | Runtime.Runtime<S>): Filtered<Exclude<R, S>, E, A>;
+    <R, E, A, S>(computed: Computed<R, E, A>, context: C.Context<S> | Runtime.Runtime<S>): Computed<Exclude<R, S>, E, A>;
+    <R, E, A, S>(ref: RefSubject<R, E, A>, context: C.Context<S> | Runtime.Runtime<S>): RefSubject<Exclude<R, S>, E, A>;
+    <R, E, A, R2, S>(filtered: Filtered<R, E, A>, layer: Layer.Layer<R2, never, S>): Filtered<Exclude<R, S> | R2, E, A>;
+    <R, E, A, R2, S>(computed: Computed<R, E, A>, layer: Layer.Layer<R2, never, S>): Computed<Exclude<R, S> | R2, E, A>;
+    <R, E, A, R2, S>(ref: RefSubject<R, E, A>, layer: Layer.Layer<R2, never, S>): RefSubject<Exclude<R, S> | R2, E, A>;
 };
 /**
- * Derive a RefSubjectSchema using the "from" or "encoded" value represented by a Schema.
+ * Set the value to true
  * @since 1.18.0
  */
-export declare function deriveFromSchema<I, O>(schema: Schema.Schema<I, O>): MakeRefSubject<I>;
+export declare const asTrue: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
 /**
- * Derive a RefSubjectSchema using the "to" or "decoded" value represented by a Schema.
+ * Set the value to false
  * @since 1.18.0
  */
-export declare function deriveToSchema<I, O>(schema: Schema.Schema<I, O>): MakeRefSubject<O>;
+export declare const asFalse: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
 /**
+ * Toggle the boolean value between true and false
  * @since 1.18.0
  */
-export declare const tuple: <const REFS extends ReadonlyArray<RefSubject.Any>>(...refs: REFS) => RefSubject<RefSubject.Context<REFS[number]>, RefSubject.Error<REFS[number]>, {
-    readonly [K in keyof REFS]: RefSubject.Success<REFS[K]>;
-}>;
+export declare const toggle: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
 /**
+ * Set the value to true
  * @since 1.18.0
  */
-export declare const struct: <const REFS extends Readonly<Record<PropertyKey, RefSubject.Any>>>(refs: REFS) => RefSubject<RefSubject.Context<REFS[string]>, RefSubject.Error<REFS[string]>, {
-    readonly [K in keyof REFS]: RefSubject.Success<REFS[K]>;
-}>;
+export declare const increment: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number>;
 /**
+ * Set the value to false
  * @since 1.18.0
  */
-export declare function fromSubscriptionRef<A>(subscriptionRef: SubscriptionRef.SubscriptionRef<A>): Effect.Effect<Scope.Scope, never, RefSubject<never, never, A>>;
+export declare const decrement: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number>;
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export declare const slice: {
+    (drop: number, take: number): <R, E, A>(ref: RefSubject<R, E, A>) => RefSubject<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A>, drop: number, take: number): RefSubject<R, E, A>;
+};
+/**
+ * @since 1.20.0
+ */
+export declare const drop: {
+    (drop: number): <R, E, A>(ref: RefSubject<R, E, A>) => RefSubject<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A>, drop: number): RefSubject<R, E, A>;
+};
+/**
+ * @since 1.20.0
  */
-export declare const transform: {
-    <A, B>(from: (a: A) => B, to: (b: B) => A): <R, E>(ref: RefSubject<R, E, A>) => RefSubject<R, E, B>;
-    <R, E, A, B>(ref: RefSubject<R, E, A>, from: (a: A) => B, to: (b: B) => A): RefSubject<R, E, B>;
+export declare const take: {
+    (take: number): <R, E, A>(ref: RefSubject<R, E, A>) => RefSubject<R, E, A>;
+    <R, E, A>(ref: RefSubject<R, E, A>, take: number): RefSubject<R, E, A>;
 };
 //# sourceMappingURL=RefSubject.d.ts.map