@typed/fx 1.22.2 → 1.24.0

package/dist/dts/RefSubject.d.ts

@@ -19,7 +19,7 @@ import * as Versioned from "./Versioned.js";
  * A Computed is essentially a readonly RefSubject.
  * @since 1.20.0
  */
-export interface Computed<out R, out E, out A> extends Versioned.Versioned<R, E, R | Scope.Scope, E, A, R, E, A> {
+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;
 }
 /**
@@ -35,12 +35,12 @@ export declare namespace Computed {
  * 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> {
+export interface Filtered<out A, out E = never, out R = never> extends Versioned.Versioned<R, E, A, E, R | Scope.Scope, A, E | Cause.NoSuchElementException, R> {
     readonly [FilteredTypeId]: FilteredTypeId;
     /**
      * @since 1.20.0
      */
-    asComputed(): Computed<R, E, Option.Option<A>>;
+    asComputed(): Computed<Option.Option<A>, E, R>;
 }
 /**
  * @since 1.20.0
@@ -55,12 +55,12 @@ export declare namespace Filtered {
  * 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> {
+export interface RefSubject<in out A, in out E = never, out R = never> extends Computed<A, E, R>, Subject.Subject<A, E, R> {
     readonly [RefSubjectTypeId]: RefSubjectTypeId;
     /**
      * @since 1.20.0
      */
-    readonly runUpdates: <R2, E2, B>(f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>) => Effect.Effect<R | R2, E2, B>;
+    readonly runUpdates: <B, E2, R2>(f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>) => Effect.Effect<B, E2, R | R2>;
 }
 /**
  * @since 1.20.0
@@ -69,40 +69,40 @@ export declare namespace RefSubject {
     /**
      * @since 1.20.0
      */
-    type Any = RefSubject<any, any, any> | RefSubject<never, any, any> | RefSubject<any, never, any> | RefSubject<never, never, any>;
+    type Any = RefSubject<any, any, any> | RefSubject<any, any> | RefSubject<any, never, any> | RefSubject<any>;
     /**
      * @since 1.20.0
      */
-    interface Tagged<I, E, A> extends RefSubject<I, E, A> {
+    interface Tagged<I, E, A> extends RefSubject<A, E, I> {
         /**
          * @since 1.20.0
          */
-        readonly tag: C.Tagged<I, RefSubject<never, E, A>>;
+        readonly tag: C.Tagged<I, RefSubject<A, E>>;
         /**
          * @since 1.20.0
          */
-        readonly make: <R>(fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>, options?: RefSubjectOptions<A>) => Layer.Layer<R, never, I>;
+        readonly make: <R>(fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R>, options?: RefSubjectOptions<A>) => Layer.Layer<I, never, R>;
     }
     /**
      * A Contextual wrapper around a RefSubject
      * @since 1.18.0
      * @category models
      */
-    interface Derived<R, E, A> extends RefSubject<R, E, A> {
-        readonly persist: Effect.Effect<R, never, void>;
+    interface Derived<A, E, R> extends RefSubject<A, E, R> {
+        readonly persist: Effect.Effect<void, never, R>;
     }
     /**
      * @since 1.20.0
      */
-    type Context<T> = T extends RefSubject<infer R, infer _E, infer _A> ? R : never;
+    type Context<T> = T extends RefSubject<infer _A, infer _E, infer R> ? R : never;
     /**
      * @since 1.20.0
      */
-    type Error<T> = T extends RefSubject<infer _R, infer E, infer _A> ? E : never;
+    type Error<T> = T extends RefSubject<infer _A, infer E, infer _R> ? E : never;
     /**
      * @since 1.20.0
      */
-    type Success<T> = T extends RefSubject<infer _R, infer _E, infer A> ? A : never;
+    type Success<T> = T extends RefSubject<infer A, infer _E, infer _R> ? A : never;
     /**
      * @since 1.20.0
      */
@@ -135,48 +135,48 @@ export interface RefSubjectOptions<A> {
 /**
  * @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>>;
+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>;
 /**
  * @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>>;
+export declare function fromFx<A, E, R>(fx: Fx<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
 /**
  * @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>>;
+export declare function fromRefSubject<A, E, R>(ref: RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
 /**
  * @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>>;
+    <A, E = never, R = never>(ref: RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
+    <A, E = never, R = never>(fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
+    <A, E = never, R = never>(fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R> | RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E> | RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
 };
 /**
  * @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>>;
+export declare function of<A, E = never>(a: A, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, Scope.Scope>;
 /**
  * @since 1.20.0
  */
 export declare function unsafeMake<E, A>(params: {
     readonly id: FiberId.FiberId;
-    readonly initial: Effect.Effect<never, E, A>;
+    readonly initial: Effect.Effect<A, E>;
     readonly options?: RefSubjectOptions<A> | undefined;
     readonly scope: Scope.CloseableScope;
     readonly initialValue?: A;
-}): Effect.Effect<never, never, RefSubject<never, E, A>>;
+}): Effect.Effect<RefSubject<A, E>>;
 /**
  * @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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
-export declare function reset<R, E, A>(ref: RefSubject<R, E, A>): Effect.Effect<R, E, Option.Option<A>>;
+export declare function reset<A, E, R>(ref: RefSubject<A, E, R>): Effect.Effect<Option.Option<A>, E, R>;
 /**
  * @since 1.20.0
  */
@@ -188,163 +188,163 @@ reset as delete };
 /**
  * @since 1.20.0
  */
-export interface GetSetDelete<R, E, A> {
+export interface GetSetDelete<A, E, R> {
     /**
      * @since 1.20.0
      */
-    readonly get: Effect.Effect<R, E, A>;
+    readonly get: Effect.Effect<A, E, R>;
     /**
      * @since 1.20.0
      */
-    readonly set: (a: A) => Effect.Effect<R, never, A>;
+    readonly set: (a: A) => Effect.Effect<A, never, R>;
     /**
      * @since 1.20.0
      */
-    readonly delete: Effect.Effect<R, E, Option.Option<A>>;
+    readonly delete: Effect.Effect<Option.Option<A>, E, R>;
 }
 /**
  * @since 1.20.0
  */
 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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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";
-    } | 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>;
+    } | undefined): (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<R | R2 | R3, E | E2 | E3, B>;
+    } | undefined): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): {
+        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Computed<B, E | E2, R | R2>;
+        <E, R>(ref: Filtered<A, E, R>): Filtered<B, E | E2, R | R2>;
+        <R0, E0, R, E, E2, R2, C>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<C, E2, R2>): Computed<C, E0 | E | E2, R0 | R | R2>;
     };
-    <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>;
+    <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>>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+        <E, R>(ref: RefSubject<A, E, R>): Computed<B, E, R>;
+        <E, R>(ref: Computed<A, E, R>): Computed<B, E, R>;
+        <E, R>(ref: Filtered<A, E, R>): Filtered<B, E, R>;
+        <R0, E0, R, E, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => B): Computed<B, E0 | E | E2, R0 | R2>;
     };
-    <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>;
+    <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>>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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>;
     };
-    <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>;
+    <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>>;
 };
 /**
  * @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>;
+        <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, 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>;
+    <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>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <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.NoSuchElementException> | Exclude<E2, Cause.NoSuchElementException>, R0 | R2 | Exclude<R, Scope.Scope>>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    <A, E, R, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Filtered<A, E | E2, R | R2>;
+    <R0, E0, A, E, R, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<boolean, E3, R3>): Filtered<A, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
 };
 /**
  * @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>;
+        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Filtered<A, E, R>;
+        <R0, E0, R, E, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => boolean): Filtered<A, E0 | E | E2, R0 | R2>;
     };
-    <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>;
+    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => boolean): Filtered<A, E, R>;
+    <R0, E0, A, E, R, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => boolean): Filtered<A, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Computed<A, E, R>;
+        <E, R>(ref: Filtered<A, E, R>): Filtered<A, E, R>;
     };
-    <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>;
+    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>, eq: Equivalence.Equivalence<A>): Computed<A, E, R>;
+    <A, E, R>(ref: Filtered<A, E, R>, eq: Equivalence.Equivalence<A>): Filtered<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, eq: Equivalence.Equivalence<A>): Computed<A, E, R> | Filtered<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-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>;
+export declare function skipRepeats<A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Computed<A, E, R>;
+export declare function skipRepeats<A, E, R>(ref: Filtered<A, E, R>): Filtered<A, E, R>;
+export declare function skipRepeats<A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Computed<A, E, R> | Filtered<A, E, R>;
 /**
  * @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>;
+export declare function transform<A, E, R, B>(ref: RefSubject<A, E, R>, from: (a: A) => B, to: (b: B) => A): RefSubject<B, E, R>;
 /**
  * @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>;
+export declare function transformOrFail<R, E, A, E2, R2, R3, E3, B>(ref: RefSubject<A, E, R>, from: (a: A) => Effect.Effect<B, E2, R2>, to: (b: B) => Effect.Effect<A, E3, R3>): RefSubject<B, E | E2 | E3, R | R2 | R3>;
 /**
  * @since 1.20.0
  */
@@ -354,9 +354,9 @@ 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;
+    "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 Ref = RefSubject.Any | Computed.Any | Filtered.Any;
 /**
@@ -368,23 +368,23 @@ export type GetTupleKind<Refs extends ReadonlyArray<Ref>, Kind extends RefKind =
  */
 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]>, {
+type FilteredTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Filtered<{
     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]>, {
+}, Fx.Error<Refs[number]>, Effect.Effect.Context<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.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]>, {
+}, Effect.Effect.Error<Refs[number]>, Effect.Effect.Context<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.Effect.Success<Refs[K]>;
-}>;
+}, Effect.Effect.Error<Refs[number]>, Effect.Effect.Context<Refs[number]>>;
 /**
  * @since 1.20.0
  */
 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;
+    "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>];
 /**
  * @since 1.20.0
@@ -393,15 +393,15 @@ export type GetStructKind<Refs extends Readonly<Record<string, RefSubject.Any |
     [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]>, {
+type FilteredStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Filtered<{
     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]>, {
+}, Fx.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
+type ComputedStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Computed<{
     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]>, {
+}, Effect.Effect.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
+type RefSubjectStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = RefSubject<{
     readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}>;
+}, Effect.Effect.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
 /**
  * @since 1.20.0
  */
@@ -412,100 +412,100 @@ export declare function tagged<E, A>(replay?: number): {
 /**
  * @since 1.20.0
  */
-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>;
+export declare function fromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => RefSubject<A, E, R>): RefSubject<A, E, I | R>;
 /**
  * @since 1.20.0
  */
-export declare function isRefSubject<R, E, A>(u: unknown): u is RefSubject<R, E, A>;
+export declare function isRefSubject<A, E, R>(u: unknown): u is RefSubject<A, E, R>;
 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<A, E, R>(u: unknown): u is Computed<A, E, R>;
 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<A, E, R>(u: unknown): u is Filtered<A, E, R>;
 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<A, E, R>(u: unknown): u is RefSubject.Derived<A, E, R>;
 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>;
+export declare function computedFromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Computed<A, E, R>): Computed<A, E, I | R>;
 /**
  * @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>;
+export declare function filteredFromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Filtered<A, E, R>): Filtered<A, E, R | I>;
 /**
  * @since 1.20.0
  */
 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>;
+        <A, E, R>(filtered: Filtered<A, E, R>): Filtered<A, E, Exclude<R, S>>;
+        <A, E, R>(computed: Computed<A, E, R>): Computed<A, E, Exclude<R, S>>;
+        <A, E, R>(ref: RefSubject<A, E, R>): RefSubject<A, E, Exclude<R, S>>;
     };
-    <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>;
+    <R2, S>(layer: Layer.Layer<S, never, R2>): {
+        <A, E, R>(filtered: Filtered<A, E, R>): Filtered<A, E, Exclude<R, S> | R2>;
+        <A, E, R>(computed: Computed<A, E, R>): Computed<A, E, Exclude<R, S> | R2>;
+        <A, E, R>(ref: RefSubject<A, E, R>): RefSubject<A, E, Exclude<R, S> | R2>;
     };
-    <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>;
+    <A, E, R, S>(filtered: Filtered<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): Filtered<A, E, Exclude<R, S>>;
+    <A, E, R, S>(computed: Computed<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): Computed<A, E, Exclude<R, S>>;
+    <A, E, R, S>(ref: RefSubject<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): RefSubject<A, E, Exclude<R, S>>;
+    <A, E, R, R2, S>(filtered: Filtered<A, E, R>, layer: Layer.Layer<S, never, R2>): Filtered<A, E, Exclude<R, S> | R2>;
+    <A, E, R, R2, S>(computed: Computed<A, E, R>, layer: Layer.Layer<S, never, R2>): Computed<A, E, Exclude<R, S> | R2>;
+    <A, E, R, R2, S>(ref: RefSubject<A, E, R>, layer: Layer.Layer<S, never, R2>): RefSubject<A, E, Exclude<R, S> | R2>;
 };
 /**
  * Set the value to true
  * @since 1.18.0
  */
-export declare const asTrue: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
+export declare const asTrue: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
 /**
  * Set the value to false
  * @since 1.18.0
  */
-export declare const asFalse: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
+export declare const asFalse: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
 /**
  * Toggle the boolean value between true and false
  * @since 1.18.0
  */
-export declare const toggle: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean>;
+export declare const toggle: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
 /**
  * Set the value to true
  * @since 1.18.0
  */
-export declare const increment: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number>;
+export declare const increment: <E, R>(ref: RefSubject<number, E, R>) => Effect.Effect<number, E, R>;
 /**
  * Set the value to false
  * @since 1.18.0
  */
-export declare const decrement: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number>;
+export declare const decrement: <E, R>(ref: RefSubject<number, E, R>) => Effect.Effect<number, E, R>;
 /**
  * @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>;
+    (drop: number, take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, drop: number, take: number): RefSubject<A, E, R>;
 };
 /**
  * @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>;
+    (drop: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, drop: number): RefSubject<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 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>;
+    (take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
+    <A, E, R>(ref: RefSubject<A, E, R>, take: number): RefSubject<A, E, R>;
 };
 //# sourceMappingURL=RefSubject.d.ts.map