effect 2.2.5 → 2.3.1

package/dist/dts/STM.d.ts

@@ -24,7 +24,7 @@ export declare const STMTypeId: unique symbol;
  */
 export type STMTypeId = typeof STMTypeId;
 /**
- * `STM<R, E, A>` represents an effect that can be performed transactionally,
+ * `STM<A, E, R>` represents an effect that can be performed transactionally,
  *  resulting in a failure `E` or a value `A` that may require an environment
  *  `R` to execute.
  *
@@ -60,7 +60,7 @@ export type STMTypeId = typeof STMTypeId;
  * @since 2.0.0
  * @category models
  */
-export interface STM<out R, out E, out A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
+export interface STM<out A, out E = never, out R = never> extends Effect.Effect<A, E, R>, STM.Variance<A, E, R>, Pipeable {
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: STMUnify<this>;
     [Unify.ignoreSymbol]?: STMUnifyIgnore;
@@ -72,7 +72,7 @@ export interface STM<out R, out E, out A> extends Effect.Effect<R, E, A>, STM.Va
 export interface STMUnify<A extends {
     [Unify.typeSymbol]?: any;
 }> extends Effect.EffectUnify<A> {
-    STM?: () => A[Unify.typeSymbol] extends STM<infer R0, infer E0, infer A0> | infer _ ? STM<R0, E0, A0> : never;
+    STM?: () => A[Unify.typeSymbol] extends STM<infer A0, infer E0, infer R0> | infer _ ? STM<R0, E0, A0> : never;
 }
 /**
  * @category models
@@ -86,14 +86,14 @@ export interface STMUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @since 2.0.0
  */
 export interface STMTypeLambda extends TypeLambda {
-    readonly type: STM<this["Out2"], this["Out1"], this["Target"]>;
+    readonly type: STM<this["Target"], this["Out1"], this["Out2"]>;
 }
 /**
  * @since 2.0.0
  * @category models
  */
 declare module "./Context.js" {
-    interface Tag<Identifier, Service> extends STM<Identifier, never, Service> {
+    interface Tag<Identifier, Service> extends STM<Service, never, Identifier> {
     }
 }
 /**
@@ -101,10 +101,10 @@ declare module "./Context.js" {
  * @category models
  */
 declare module "./Either.js" {
-    interface Left<E, A> extends STM<never, E, A> {
+    interface Left<E, A> extends STM<A, E> {
         readonly _tag: "Left";
     }
-    interface Right<E, A> extends STM<never, E, A> {
+    interface Right<E, A> extends STM<A, E> {
         readonly _tag: "Right";
     }
 }
@@ -113,10 +113,10 @@ declare module "./Either.js" {
  * @category models
  */
 declare module "./Option.js" {
-    interface None<A> extends STM<never, Cause.NoSuchElementException, A> {
+    interface None<A> extends STM<A, Cause.NoSuchElementException> {
         readonly _tag: "None";
     }
-    interface Some<A> extends STM<never, Cause.NoSuchElementException, A> {
+    interface Some<A> extends STM<A, Cause.NoSuchElementException> {
         readonly _tag: "Some";
     }
 }
@@ -128,11 +128,11 @@ export declare namespace STM {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out R, out E, out A> {
+    interface Variance<out A, out E, out R> {
         readonly [STMTypeId]: {
-            readonly _R: Covariant<R>;
-            readonly _E: Covariant<E>;
             readonly _A: Covariant<A>;
+            readonly _E: Covariant<E>;
+            readonly _R: Covariant<R>;
         };
     }
 }
@@ -140,12 +140,12 @@ export declare namespace STM {
  * @category models
  * @since 2.0.0
  */
-export interface STMGen<out R, out E, out A> {
-    readonly _R: () => R;
-    readonly _E: () => E;
+export interface STMGen<out A, out E, out R> {
     readonly _A: () => A;
-    readonly value: STM<R, E, A>;
-    [Symbol.iterator](): Generator<STMGen<R, E, A>, A>;
+    readonly _E: () => E;
+    readonly _R: () => R;
+    readonly value: STM<A, E, R>;
+    [Symbol.iterator](): Generator<STMGen<A, E, R>, A>;
 }
 /**
  * Returns `true` if the provided value is an `STM`, `false` otherwise.
@@ -164,8 +164,8 @@ export declare const isSTM: (u: unknown) => u is STM<unknown, unknown, unknown>;
  * @category constructors
  */
 export declare const acquireUseRelease: {
-    <A, R2, E2, A2, R3, E3, A3>(use: (resource: A) => STM<R2, E2, A2>, release: (resource: A) => STM<R3, E3, A3>): <R, E>(acquire: STM<R, E, A>) => Effect.Effect<R2 | R3 | R, E2 | E3 | E, A2>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(acquire: STM<R, E, A>, use: (resource: A) => STM<R2, E2, A2>, release: (resource: A) => STM<R3, E3, A3>): Effect.Effect<R | R2 | R3, E | E2 | E3, A2>;
+    <A, R2, E2, A2, R3, E3, A3>(use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): <R, E>(acquire: STM<A, E, R>) => Effect.Effect<A2, E2 | E3 | E, R2 | R3 | R>;
+    <R, E, A, R2, E2, A2, R3, E3, A3>(acquire: STM<A, E, R>, use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): Effect.Effect<A2, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * @since 2.0.0
@@ -173,31 +173,31 @@ export declare const acquireUseRelease: {
  */
 export declare namespace All {
     type STMAny = STM<any, any, any>;
-    type ReturnTuple<T extends ReadonlyArray<STM<any, any, any>>, Discard extends boolean> = STM<T[number] extends never ? never : [T[number]] extends [{
-        [STMTypeId]: {
-            _R: (_: never) => infer R;
-        };
-    }] ? R : never, T[number] extends never ? never : [T[number]] extends [{
+    type ReturnTuple<T extends ReadonlyArray<STM<any, any, any>>, Discard extends boolean> = STM<Discard extends true ? void : T[number] extends never ? [] : {
+        -readonly [K in keyof T]: [T[K]] extends [STM<infer A, infer _E, infer _R>] ? A : never;
+    }, T[number] extends never ? never : [T[number]] extends [{
         [STMTypeId]: {
             _E: (_: never) => infer E;
         };
-    }] ? E : never, Discard extends true ? void : T[number] extends never ? [] : {
-        -readonly [K in keyof T]: [T[K]] extends [STM<infer _R, infer _E, infer A>] ? A : never;
-    }> extends infer X ? X : never;
-    type ReturnIterable<T extends Iterable<STMAny>, Discard extends boolean> = [T] extends [
-        Iterable<STM.Variance<infer R, infer E, infer A>>
-    ] ? STM<R, E, Discard extends true ? void : Array<A>> : never;
-    type ReturnObject<T extends Record<string, STMAny>, Discard extends boolean> = STM<keyof T extends never ? never : [T[keyof T]] extends [{
+    }] ? E : never, T[number] extends never ? never : [T[number]] extends [{
         [STMTypeId]: {
             _R: (_: never) => infer R;
         };
-    }] ? R : never, keyof T extends never ? never : [T[keyof T]] extends [{
+    }] ? R : never> extends infer X ? X : never;
+    type ReturnIterable<T extends Iterable<STMAny>, Discard extends boolean> = [T] extends [
+        Iterable<STM.Variance<infer A, infer E, infer R>>
+    ] ? STM<Discard extends true ? void : Array<A>, E, R> : never;
+    type ReturnObject<T extends Record<string, STMAny>, Discard extends boolean> = STM<Discard extends true ? void : {
+        -readonly [K in keyof T]: [T[K]] extends [STM.Variance<infer A, infer _E, infer _R>] ? A : never;
+    }, keyof T extends never ? never : [T[keyof T]] extends [{
         [STMTypeId]: {
             _E: (_: never) => infer E;
         };
-    }] ? E : never, Discard extends true ? void : {
-        -readonly [K in keyof T]: [T[K]] extends [STM.Variance<infer _R, infer _E, infer A>] ? A : never;
-    }>;
+    }] ? E : never, keyof T extends never ? never : [T[keyof T]] extends [{
+        [STMTypeId]: {
+            _R: (_: never) => infer R;
+        };
+    }] ? R : never>;
     /**
      * @since 2.0.0
      * @category utils
@@ -235,8 +235,8 @@ export declare const all: All.Signature;
  * @category mapping
  */
 export declare const as: {
-    <A2>(value: A2): <R, E, A>(self: STM<R, E, A>) => STM<R, E, A2>;
-    <R, E, A, A2>(self: STM<R, E, A>, value: A2): STM<R, E, A2>;
+    <A2>(value: A2): <A, E, R>(self: STM<A, E, R>) => STM<A2, E, R>;
+    <R, E, A, A2>(self: STM<A, E, R>, value: A2): STM<A2, E, R>;
 };
 /**
  * Maps the success value of this effect to an optional value.
@@ -244,14 +244,14 @@ export declare const as: {
  * @since 2.0.0
  * @category mapping
  */
-export declare const asSome: <R, E, A>(self: STM<R, E, A>) => STM<R, E, Option.Option<A>>;
+export declare const asSome: <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E, R>;
 /**
  * Maps the error value of this effect to an optional value.
  *
  * @since 2.0.0
  * @category mapping
  */
-export declare const asSomeError: <R, E, A>(self: STM<R, E, A>) => STM<R, Option.Option<E>, A>;
+export declare const asSomeError: <A, E, R>(self: STM<A, E, R>) => STM<A, Option.Option<E>, R>;
 /**
  * This function maps the success value of an `STM` to `void`. If the original
  * `STM` succeeds, the returned `STM` will also succeed. If the original `STM`
@@ -260,14 +260,14 @@ export declare const asSomeError: <R, E, A>(self: STM<R, E, A>) => STM<R, Option
  * @since 2.0.0
  * @category mapping
  */
-export declare const asUnit: <R, E, A>(self: STM<R, E, A>) => STM<R, E, void>;
+export declare const asUnit: <A, E, R>(self: STM<A, E, R>) => STM<void, E, R>;
 /**
  * Creates an `STM` value from a partial (but pure) function.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const attempt: <A>(evaluate: LazyArg<A>) => STM<never, unknown, A>;
+export declare const attempt: <A>(evaluate: LazyArg<A>) => STM<A, unknown>;
 /**
  * Recovers from all errors.
  *
@@ -275,8 +275,8 @@ export declare const attempt: <A>(evaluate: LazyArg<A>) => STM<never, unknown, A
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>): <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1, B | A>;
-    <R, A, E, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => STM<R1, E1, B>): STM<R | R1, E1, A | B>;
+    <E, R1, E1, B>(f: (e: E) => STM<B, E1, R1>): <R, A>(self: STM<A, E, R>) => STM<B | A, E1, R1 | R>;
+    <R, A, E, R1, E1, B>(self: STM<A, E, R>, f: (e: E) => STM<B, E1, R1>): STM<A | B, E1, R | R1>;
 };
 /**
  * Recovers from some or all of the error cases.
@@ -285,8 +285,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchSome: {
-    <E, R2, E2, A2>(pf: (error: E) => Option.Option<STM<R2, E2, A2>>): <R, A>(self: STM<R, E, A>) => STM<R2 | R, E | E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: STM<R, E, A>, pf: (error: E) => Option.Option<STM<R2, E2, A2>>): STM<R | R2, E | E2, A | A2>;
+    <E, R2, E2, A2>(pf: (error: E) => Option.Option<STM<A2, E2, R2>>): <R, A>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>;
+    <R, A, E, R2, E2, A2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from the specified tagged error.
@@ -299,16 +299,16 @@ export declare const catchTag: {
         _tag: string;
     }, R1, E1, A1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => STM<R1, E1, A1>): <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | Exclude<E, {
+    }>) => STM<A1, E1, R1>): <R, A>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, {
         _tag: K;
-    }>, A1 | A>;
+    }>, R1 | R>;
     <R, E extends {
         _tag: string;
-    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: STM<R, E, A>, k: K, f: (e: Extract<E, {
+    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: STM<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => STM<R1, E1, A1>): STM<R | R1, E1 | Exclude<E, {
+    }>) => STM<A1, E1, R1>): STM<A | A1, E1 | Exclude<E, {
         _tag: K;
-    }>, A | A1>;
+    }>, R | R1>;
 };
 /**
  * Recovers from multiple tagged errors.
@@ -323,14 +323,14 @@ export declare const catchTags: {
         [K in E["_tag"]]+?: ((error: Extract<E, {
             _tag: K;
         }>) => STM<any, any, any>);
-    }>(cases: Cases): <R, A>(self: STM<R, E, A>) => STM<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<infer R, any, any> ? R : never;
+    }>(cases: Cases): <R, A>(self: STM<A, E, R>) => STM<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<infer A, any, any> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
     }> | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, infer E, any> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, any, infer A> ? A : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, any, infer R> ? R : never;
     }[keyof Cases]>;
     <R, E extends {
         _tag: string;
@@ -338,14 +338,14 @@ export declare const catchTags: {
         [K in E["_tag"]]+?: ((error: Extract<E, {
             _tag: K;
         }>) => STM<any, any, any>);
-    }>(self: STM<R, E, A>, cases: Cases): STM<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<infer R, any, any> ? R : never;
+    }>(self: STM<A, E, R>, cases: Cases): STM<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<infer A, any, any> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
     }> | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, infer E, any> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, any, infer A> ? A : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, any, infer R> ? R : never;
     }[keyof Cases]>;
 };
 /**
@@ -354,7 +354,7 @@ export declare const catchTags: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const check: (predicate: LazyArg<boolean>) => STM<never, never, void>;
+export declare const check: (predicate: LazyArg<boolean>) => STM<void>;
 /**
  * Simultaneously filters and maps the value produced by this effect.
  *
@@ -362,8 +362,8 @@ export declare const check: (predicate: LazyArg<boolean>) => STM<never, never, v
  * @category mutations
  */
 export declare const collect: {
-    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: STM<R, E, A>) => STM<R, E, A2>;
-    <R, E, A, A2>(self: STM<R, E, A>, pf: (a: A) => Option.Option<A2>): STM<R, E, A2>;
+    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: STM<A, E, R>) => STM<A2, E, R>;
+    <R, E, A, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<A2>): STM<A2, E, R>;
 };
 /**
  * Simultaneously filters and maps the value produced by this effect.
@@ -372,8 +372,8 @@ export declare const collect: {
  * @category mutations
  */
 export declare const collectSTM: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<STM<R2, E2, A2>>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: STM<R, E, A>, pf: (a: A) => Option.Option<STM<R2, E2, A2>>): STM<R | R2, E | E2, A2>;
+    <A, R2, E2, A2>(pf: (a: A) => Option.Option<STM<A2, E2, R2>>): <R, E>(self: STM<A, E, R>) => STM<A2, E2 | E, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<A2, E2, R2>>): STM<A2, E | E2, R | R2>;
 };
 /**
  * Commits this transaction atomically.
@@ -381,7 +381,7 @@ export declare const collectSTM: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const commit: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E, A>;
+export declare const commit: <A, E, R>(self: STM<A, E, R>) => Effect.Effect<A, E, R>;
 /**
  * Commits this transaction atomically, regardless of whether the transaction
  * is a success or a failure.
@@ -389,7 +389,7 @@ export declare const commit: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E
  * @since 2.0.0
  * @category destructors
  */
-export declare const commitEither: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E, A>;
+export declare const commitEither: <A, E, R>(self: STM<A, E, R>) => Effect.Effect<A, E, R>;
 /**
  * Similar to Either.cond, evaluate the predicate, return the given A as
  * success if predicate returns true, and the given E as error otherwise
@@ -397,28 +397,28 @@ export declare const commitEither: <R, E, A>(self: STM<R, E, A>) => Effect.Effec
  * @since 2.0.0
  * @category constructors
  */
-export declare const cond: <E, A>(predicate: LazyArg<boolean>, error: LazyArg<E>, result: LazyArg<A>) => STM<never, E, A>;
+export declare const cond: <A, E>(predicate: LazyArg<boolean>, error: LazyArg<E>, result: LazyArg<A>) => STM<A, E>;
 /**
  * Retrieves the environment inside an stm.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const context: <R>() => STM<R, never, Context.Context<R>>;
+export declare const context: <R>() => STM<Context.Context<R>, never, R>;
 /**
  * Accesses the environment of the transaction to perform a transaction.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWith: <R0, R>(f: (environment: Context.Context<R0>) => R) => STM<R0, never, R>;
+export declare const contextWith: <R0, R>(f: (environment: Context.Context<R0>) => R) => STM<R, never, R0>;
 /**
  * Accesses the environment of the transaction to perform a transaction.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWithSTM: <R0, R, E, A>(f: (environment: Context.Context<R0>) => STM<R, E, A>) => STM<R0 | R, E, A>;
+export declare const contextWithSTM: <R0, R, E, A>(f: (environment: Context.Context<R0>) => STM<A, E, R>) => STM<A, E, R0 | R>;
 /**
  * Transforms the environment being provided to this effect with the specified
  * function.
@@ -427,8 +427,8 @@ export declare const contextWithSTM: <R0, R, E, A>(f: (environment: Context.Cont
  * @category context
  */
 export declare const mapInputContext: {
-    <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <E, A>(self: STM<R, E, A>) => STM<R0, E, A>;
-    <E, A, R0, R>(self: STM<R, E, A>, f: (context: Context.Context<R0>) => Context.Context<R>): STM<R0, E, A>;
+    <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E, R0>;
+    <A, E, R0, R>(self: STM<A, E, R>, f: (context: Context.Context<R0>) => Context.Context<R>): STM<A, E, R0>;
 };
 /**
  * Fails the transactional effect with the specified defect.
@@ -436,7 +436,7 @@ export declare const mapInputContext: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const die: (defect: unknown) => STM<never, never, never>;
+export declare const die: (defect: unknown) => STM<never>;
 /**
  * Kills the fiber running the effect with a `Cause.RuntimeException` that
  * contains the specified message.
@@ -444,21 +444,21 @@ export declare const die: (defect: unknown) => STM<never, never, never>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieMessage: (message: string) => STM<never, never, never>;
+export declare const dieMessage: (message: string) => STM<never>;
 /**
  * Fails the transactional effect with the specified lazily evaluated defect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieSync: (evaluate: LazyArg<unknown>) => STM<never, never, never>;
+export declare const dieSync: (evaluate: LazyArg<unknown>) => STM<never>;
 /**
  * Converts the failure channel into an `Either`.
  *
  * @since 2.0.0
  * @category mutations
  */
-export declare const either: <R, E, A>(self: STM<R, E, A>) => STM<R, never, Either.Either<E, A>>;
+export declare const either: <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<E, A>, never, R>;
 /**
  * Executes the specified finalization transaction whether or not this effect
  * succeeds. Note that as with all STM transactions, if the full transaction
@@ -468,8 +468,8 @@ export declare const either: <R, E, A>(self: STM<R, E, A>) => STM<R, never, Eith
  * @category finalization
  */
 export declare const ensuring: {
-    <R1, B>(finalizer: STM<R1, never, B>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E, A>;
-    <R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>): STM<R | R1, E, A>;
+    <R1, B>(finalizer: STM<B, never, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, R1 | R>;
+    <R, E, A, R1, B>(self: STM<A, E, R>, finalizer: STM<B, never, R1>): STM<A, E, R | R1>;
 };
 /**
  * Returns an effect that ignores errors and runs repeatedly until it
@@ -478,7 +478,7 @@ export declare const ensuring: {
  * @since 2.0.0
  * @category mutations
  */
-export declare const eventually: <R, E, A>(self: STM<R, E, A>) => STM<R, E, A>;
+export declare const eventually: <A, E, R>(self: STM<A, E, R>) => STM<A, E, R>;
 /**
  * Determines whether all elements of the `Iterable<A>` satisfy the effectual
  * predicate.
@@ -487,8 +487,8 @@ export declare const eventually: <R, E, A>(self: STM<R, E, A>) => STM<R, E, A>;
  * @category constructors
  */
 export declare const every: {
-    <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>;
-    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, boolean>;
+    <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
+    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
 };
 /**
  * Determines whether any element of the `Iterable[A]` satisfies the effectual
@@ -498,8 +498,8 @@ export declare const every: {
  * @category constructors
  */
 export declare const exists: {
-    <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>;
-    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, boolean>;
+    <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
+    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
 };
 /**
  * Fails the transactional effect with the specified error.
@@ -507,21 +507,21 @@ export declare const exists: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(error: E) => STM<never, E, never>;
+export declare const fail: <E>(error: E) => STM<never, E>;
 /**
  * Fails the transactional effect with the specified lazily evaluated error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => STM<never, E, never>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => STM<never, E>;
 /**
  * Returns the fiber id of the fiber committing the transaction.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fiberId: STM<never, never, FiberId.FiberId>;
+export declare const fiberId: STM<FiberId.FiberId>;
 /**
  * Filters the collection using the specified effectual predicate.
  *
@@ -529,8 +529,8 @@ export declare const fiberId: STM<never, never, FiberId.FiberId>;
  * @category constructors
  */
 export declare const filter: {
-    <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>;
-    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, Array<A>>;
+    <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
+    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
 };
 /**
  * Filters the collection using the specified effectual predicate, removing
@@ -540,8 +540,8 @@ export declare const filter: {
  * @category constructors
  */
 export declare const filterNot: {
-    <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>;
-    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, Array<A>>;
+    <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
+    <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
 };
 /**
  * Dies with specified defect if the predicate fails.
@@ -550,10 +550,10 @@ export declare const filterNot: {
  * @category filtering
  */
 export declare const filterOrDie: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<R, E, B>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<R, E, A>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<B, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<A, E, R>;
 };
 /**
  * Dies with a `Cause.RuntimeException` having the specified  message if the
@@ -563,10 +563,10 @@ export declare const filterOrDie: {
  * @category filtering
  */
 export declare const filterOrDieMessage: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>, message: string): STM<R, E, B>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>, message: string): STM<R, E, A>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM<B, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, message: string): STM<A, E, R>;
 };
 /**
  * Supplies `orElse` if the predicate fails.
@@ -575,10 +575,10 @@ export declare const filterOrDieMessage: {
  * @category filtering
  */
 export declare const filterOrElse: {
-    <A, B extends A, R2, E2, C>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<R2, E2, C>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, B | C>;
-    <A, R2, E2, B>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<R2, E2, B>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A | B>;
-    <R, E, A, B extends A, R2, E2, C>(self: STM<R, E, A>, refinement: Refinement<A, B>, orElse: (a: A) => STM<R2, E2, C>): STM<R | R2, E | E2, B | C>;
-    <R, E, A, R2, E2, B>(self: STM<R, E, A>, predicate: Predicate<A>, orElse: (a: A) => STM<R2, E2, B>): STM<R | R2, E | E2, A | B>;
+    <A, B extends A, R2, E2, C>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<C, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<B | C, E2 | E, R2 | R>;
+    <A, R2, E2, B>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<B, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<A | B, E2 | E, R2 | R>;
+    <R, E, A, B extends A, R2, E2, C>(self: STM<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => STM<C, E2, R2>): STM<B | C, E | E2, R | R2>;
+    <R, E, A, R2, E2, B>(self: STM<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => STM<B, E2, R2>): STM<A | B, E | E2, R | R2>;
 };
 /**
  * Fails with the specified error if the predicate fails.
@@ -587,10 +587,10 @@ export declare const filterOrElse: {
  * @category filtering
  */
 export declare const filterOrFail: {
-    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<R, E, A>) => STM<R, E2 | E, B>;
-    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<R, E, A>) => STM<R, E2 | E, A>;
-    <R, E, A, B extends A, E2>(self: STM<R, E, A>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<R, E | E2, B>;
-    <R, E, A, E2>(self: STM<R, E, A>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<R, E | E2, A>;
+    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<A, E, R>) => STM<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    <R, E, A, B extends A, E2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<B, E | E2, R>;
+    <R, E, A, E2>(self: STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<A, E | E2, R>;
 };
 /**
  * Feeds the value produced by this effect to the specified function, and then
@@ -600,8 +600,8 @@ export declare const filterOrFail: {
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R1, E1, A2>(f: (a: A) => STM<R1, E1, A2>): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2>;
-    <R, E, A, R1, E1, A2>(self: STM<R, E, A>, f: (a: A) => STM<R1, E1, A2>): STM<R | R1, E | E1, A2>;
+    <A, R1, E1, A2>(f: (a: A) => STM<A2, E1, R1>): <R, E>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    <R, E, A, R1, E1, A2>(self: STM<A, E, R>, f: (a: A) => STM<A2, E1, R1>): STM<A2, E | E1, R | R1>;
 };
 /**
  * Flattens out a nested `STM` effect.
@@ -609,7 +609,7 @@ export declare const flatMap: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flatten: <R, E, R2, E2, A>(self: STM<R, E, STM<R2, E2, A>>) => STM<R | R2, E | E2, A>;
+export declare const flatten: <R, E, R2, E2, A>(self: STM<STM<A, E2, R2>, E, R>) => STM<A, E | E2, R | R2>;
 /**
  * Flips the success and failure channels of this transactional effect. This
  * allows you to use all methods on the error channel, possibly before
@@ -618,7 +618,7 @@ export declare const flatten: <R, E, R2, E2, A>(self: STM<R, E, STM<R2, E2, A>>)
  * @since 2.0.0
  * @category mutations
  */
-export declare const flip: <R, E, A>(self: STM<R, E, A>) => STM<R, A, E>;
+export declare const flip: <A, E, R>(self: STM<A, E, R>) => STM<E, A, R>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the
  * parameters back
@@ -627,8 +627,8 @@ export declare const flip: <R, E, A>(self: STM<R, E, A>) => STM<R, A, E>;
  * @category mutations
  */
 export declare const flipWith: {
-    <R, A, E, R2, A2, E2>(f: (stm: STM<R, A, E>) => STM<R2, A2, E2>): (self: STM<R, E, A>) => STM<R | R2, E | E2, A | A2>;
-    <R, A, E, R2, A2, E2>(self: STM<R, E, A>, f: (stm: STM<R, A, E>) => STM<R2, A2, E2>): STM<R | R2, E | E2, A | A2>;
+    <R, A, E, R2, A2, E2>(f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): (self: STM<A, E, R>) => STM<A | A2, E | E2, R | R2>;
+    <R, A, E, R2, A2, E2>(self: STM<A, E, R>, f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): STM<A | A2, E | E2, R | R2>;
 };
 /**
  * Folds over the `STM` effect, handling both failure and success, but not
@@ -641,11 +641,11 @@ export declare const match: {
     <E, A2, A, A3>(options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
-    }): <R>(self: STM<R, E, A>) => STM<R, never, A2 | A3>;
-    <R, E, A2, A, A3>(self: STM<R, E, A>, options: {
+    }): <R>(self: STM<A, E, R>) => STM<A2 | A3, never, R>;
+    <R, E, A2, A, A3>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
-    }): STM<R, never, A2 | A3>;
+    }): STM<A2 | A3, never, R>;
 };
 /**
  * Effectfully folds over the `STM` effect, handling both failure and success.
@@ -655,13 +655,13 @@ export declare const match: {
  */
 export declare const matchSTM: {
     <E, R1, E1, A1, A, R2, E2, A2>(options: {
-        readonly onFailure: (e: E) => STM<R1, E1, A1>;
-        readonly onSuccess: (a: A) => STM<R2, E2, A2>;
-    }): <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, A1 | A2>;
-    <R, E, R1, E1, A1, A, R2, E2, A2>(self: STM<R, E, A>, options: {
-        readonly onFailure: (e: E) => STM<R1, E1, A1>;
-        readonly onSuccess: (a: A) => STM<R2, E2, A2>;
-    }): STM<R | R1 | R2, E1 | E2, A1 | A2>;
+        readonly onFailure: (e: E) => STM<A1, E1, R1>;
+        readonly onSuccess: (a: A) => STM<A2, E2, R2>;
+    }): <R>(self: STM<A, E, R>) => STM<A1 | A2, E1 | E2, R1 | R2 | R>;
+    <R, E, R1, E1, A1, A, R2, E2, A2>(self: STM<A, E, R>, options: {
+        readonly onFailure: (e: E) => STM<A1, E1, R1>;
+        readonly onSuccess: (a: A) => STM<A2, E2, R2>;
+    }): STM<A1 | A2, E1 | E2, R | R1 | R2>;
 };
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and returns
@@ -671,18 +671,18 @@ export declare const matchSTM: {
  * @category traversing
  */
 export declare const forEach: {
-    <A, R, E, A2>(f: (a: A) => STM<R, E, A2>, options?: {
+    <A, R, E, A2>(f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
-    }): (elements: Iterable<A>) => STM<R, E, Array<A2>>;
-    <A, R, E, A2>(f: (a: A) => STM<R, E, A2>, options: {
+    }): (elements: Iterable<A>) => STM<Array<A2>, E, R>;
+    <A, R, E, A2>(f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
-    }): (elements: Iterable<A>) => STM<R, E, void>;
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>, options?: {
+    }): (elements: Iterable<A>) => STM<void, E, R>;
+    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
-    }): STM<R, E, Array<A2>>;
-    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>, options: {
+    }): STM<Array<A2>, E, R>;
+    <A, R, E, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
-    }): STM<R, E, void>;
+    }): STM<void, E, R>;
 };
 /**
  * Lifts an `Either` into a `STM`.
@@ -690,50 +690,50 @@ export declare const forEach: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEither: <E, A>(either: Either.Either<E, A>) => STM<never, E, A>;
+export declare const fromEither: <E, A>(either: Either.Either<E, A>) => STM<A, E>;
 /**
  * Lifts an `Option` into a `STM`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromOption: <A>(option: Option.Option<A>) => STM<never, Option.Option<never>, A>;
+export declare const fromOption: <A>(option: Option.Option<A>) => STM<A, Option.Option<never>>;
 /**
  * @since 2.0.0
  * @category models
  */
 export interface Adapter {
-    <R, E, A>(self: STM<R, E, A>): STMGen<R, E, A>;
-    <A, _R, _E, _A>(a: A, ab: (a: A) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: F) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (g: H) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
-    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => STM<_R, _E, _A>): STMGen<_R, _E, _A>;
+    <A, E, R>(self: STM<A, E, R>): STMGen<A, E, R>;
+    <A, _R, _E, _A>(a: A, ab: (a: A) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: F) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (g: H) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => STM<_A, _E, _R>): STMGen<_A, _E, _R>;
 }
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const gen: <Eff extends STMGen<any, any, any>, AEff>(f: (resume: Adapter) => Generator<Eff, AEff, any>) => STM<[
+export declare const gen: <Eff extends STMGen<any, any, any>, AEff>(f: (resume: Adapter) => Generator<Eff, AEff, any>) => STM<AEff, [
     Eff
-] extends [never] ? never : [Eff] extends [STMGen<infer R, any, any>] ? R : never, [
+] extends [never] ? never : [Eff] extends [STMGen<any, infer E, any>] ? E : never, [
     Eff
-] extends [never] ? never : [Eff] extends [STMGen<any, infer E, any>] ? E : never, AEff>;
+] extends [never] ? never : [Eff] extends [STMGen<any, any, infer R>] ? R : never>;
 /**
  * Returns a successful effect with the head of the list if the list is
  * non-empty or fails with the error `None` if the list is empty.
@@ -741,20 +741,20 @@ export declare const gen: <Eff extends STMGen<any, any, any>, AEff>(f: (resume:
  * @since 2.0.0
  * @category getters
  */
-export declare const head: <R, E, A>(self: STM<R, E, Iterable<A>>) => STM<R, Option.Option<E>, A>;
+export declare const head: <A, E, R>(self: STM<Iterable<A>, E, R>) => STM<A, Option.Option<E>, R>;
 declare const if_: {
     <R1, R2, E1, E2, A, A1>(options: {
-        readonly onTrue: STM<R1, E1, A>;
-        readonly onFalse: STM<R2, E2, A1>;
-    }): <R = never, E = never>(self: boolean | STM<R, E, boolean>) => STM<R1 | R2 | R, E1 | E2 | E, A | A1>;
+        readonly onTrue: STM<A, E1, R1>;
+        readonly onFalse: STM<A1, E2, R2>;
+    }): <R = never, E = never>(self: boolean | STM<boolean, E, R>) => STM<A | A1, E1 | E2 | E, R1 | R2 | R>;
     <R, E, R1, R2, E1, E2, A, A1>(self: boolean, options: {
-        readonly onTrue: STM<R1, E1, A>;
-        readonly onFalse: STM<R2, E2, A1>;
-    }): STM<R | R1 | R2, E | E1 | E2, A | A1>;
-    <R, E, R1, R2, E1, E2, A, A1>(self: STM<R, E, boolean>, options: {
-        readonly onTrue: STM<R1, E1, A>;
-        readonly onFalse: STM<R2, E2, A1>;
-    }): STM<R | R1 | R2, E | E1 | E2, A | A1>;
+        readonly onTrue: STM<A, E1, R1>;
+        readonly onFalse: STM<A1, E2, R2>;
+    }): STM<A | A1, E | E1 | E2, R | R1 | R2>;
+    <R, E, R1, R2, E1, E2, A, A1>(self: STM<boolean, E, R>, options: {
+        readonly onTrue: STM<A, E1, R1>;
+        readonly onFalse: STM<A1, E2, R2>;
+    }): STM<A | A1, E | E1 | E2, R | R1 | R2>;
 };
 export { 
 /**
@@ -770,35 +770,35 @@ if_ as if };
  * @since 2.0.0
  * @category mutations
  */
-export declare const ignore: <R, E, A>(self: STM<R, E, A>) => STM<R, never, void>;
+export declare const ignore: <A, E, R>(self: STM<A, E, R>) => STM<void, never, R>;
 /**
  * Interrupts the fiber running the effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const interrupt: STM<never, never, never>;
+export declare const interrupt: STM<never>;
 /**
  * Interrupts the fiber running the effect with the specified `FiberId`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const interruptAs: (fiberId: FiberId.FiberId) => STM<never, never, never>;
+export declare const interruptAs: (fiberId: FiberId.FiberId) => STM<never>;
 /**
  * Returns whether this transactional effect is a failure.
  *
  * @since 2.0.0
  * @category getters
  */
-export declare const isFailure: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>;
+export declare const isFailure: <A, E, R>(self: STM<A, E, R>) => STM<boolean, never, R>;
 /**
  * Returns whether this transactional effect is a success.
  *
  * @since 2.0.0
  * @category getters
  */
-export declare const isSuccess: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>;
+export declare const isSuccess: <A, E, R>(self: STM<A, E, R>) => STM<boolean, never, R>;
 /**
  * Iterates with the specified transactional function. The moral equivalent
  * of:
@@ -818,8 +818,8 @@ export declare const isSuccess: <R, E, A>(self: STM<R, E, A>) => STM<R, never, b
  */
 export declare const iterate: <R, E, Z>(initial: Z, options: {
     readonly while: Predicate<Z>;
-    readonly body: (z: Z) => STM<R, E, Z>;
-}) => STM<R, E, Z>;
+    readonly body: (z: Z) => STM<Z, E, R>;
+}) => STM<Z, E, R>;
 /**
  * Loops with the specified transactional function, collecting the results
  * into a list. The moral equivalent of:
@@ -843,15 +843,15 @@ export declare const loop: {
     <Z, R, E, A>(initial: Z, options: {
         readonly while: Predicate<Z>;
         readonly step: (z: Z) => Z;
-        readonly body: (z: Z) => STM<R, E, A>;
+        readonly body: (z: Z) => STM<A, E, R>;
         readonly discard?: false | undefined;
-    }): STM<R, E, Array<A>>;
+    }): STM<Array<A>, E, R>;
     <Z, R, E, A>(initial: Z, options: {
         readonly while: Predicate<Z>;
         readonly step: (z: Z) => Z;
-        readonly body: (z: Z) => STM<R, E, A>;
+        readonly body: (z: Z) => STM<A, E, R>;
         readonly discard: true;
-    }): STM<R, E, void>;
+    }): STM<void, E, R>;
 };
 /**
  * Maps the value produced by the effect.
@@ -860,8 +860,8 @@ export declare const loop: {
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
-    <R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B): STM<R, E, B>;
+    <A, B>(f: (a: A) => B): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
+    <R, E, A, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, E, R>;
 };
 /**
  * Maps the value produced by the effect with the specified function that may
@@ -872,8 +872,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapAttempt: {
-    <A, B>(f: (a: A) => B): <R, E>(self: STM<R, E, A>) => STM<R, unknown, B>;
-    <R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B): STM<R, unknown, B>;
+    <A, B>(f: (a: A) => B): <R, E>(self: STM<A, E, R>) => STM<B, unknown, R>;
+    <R, E, A, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, unknown, R>;
 };
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped
@@ -886,11 +886,11 @@ export declare const mapBoth: {
     <E, E2, A, A2>(options: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
-    }): <R>(self: STM<R, E, A>) => STM<R, E2, A2>;
-    <R, E, E2, A, A2>(self: STM<R, E, A>, options: {
+    }): <R>(self: STM<A, E, R>) => STM<A2, E2, R>;
+    <R, E, E2, A, A2>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
-    }): STM<R, E2, A2>;
+    }): STM<A2, E2, R>;
 };
 /**
  * Maps from one error type to another.
@@ -899,8 +899,8 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, A>(self: STM<R, E, A>) => STM<R, E2, A>;
-    <R, A, E, E2>(self: STM<R, E, A>, f: (error: E) => E2): STM<R, E2, A>;
+    <E, E2>(f: (error: E) => E2): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <R, A, E, E2>(self: STM<A, E, R>, f: (error: E) => E2): STM<A, E2, R>;
 };
 /**
  * Returns a new effect where the error channel has been merged into the
@@ -909,7 +909,7 @@ export declare const mapError: {
  * @since 2.0.0
  * @category mutations
  */
-export declare const merge: <R, E, A>(self: STM<R, E, A>) => STM<R, never, E | A>;
+export declare const merge: <A, E, R>(self: STM<A, E, R>) => STM<E | A, never, R>;
 /**
  * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
  *
@@ -917,8 +917,8 @@ export declare const merge: <R, E, A>(self: STM<R, E, A>) => STM<R, never, E | A
  * @category constructors
  */
 export declare const mergeAll: {
-    <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <R, E>(iterable: Iterable<STM<R, E, A>>) => STM<R, E, A2>;
-    <R, E, A2, A>(iterable: Iterable<STM<R, E, A>>, zero: A2, f: (a2: A2, a: A) => A2): STM<R, E, A2>;
+    <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <R, E>(iterable: Iterable<STM<A, E, R>>) => STM<A2, E, R>;
+    <R, E, A2, A>(iterable: Iterable<STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM<A2, E, R>;
 };
 /**
  * Returns a new effect where boolean value of this effect is negated.
@@ -926,21 +926,21 @@ export declare const mergeAll: {
  * @since 2.0.0
  * @category mutations
  */
-export declare const negate: <R, E>(self: STM<R, E, boolean>) => STM<R, E, boolean>;
+export declare const negate: <R, E>(self: STM<boolean, E, R>) => STM<boolean, E, R>;
 /**
  * Requires the option produced by this value to be `None`.
  *
  * @since 2.0.0
  * @category mutations
  */
-export declare const none: <R, E, A>(self: STM<R, E, Option.Option<A>>) => STM<R, Option.Option<E>, void>;
+export declare const none: <A, E, R>(self: STM<Option.Option<A>, E, R>) => STM<void, Option.Option<E>, R>;
 /**
  * Converts the failure channel into an `Option`.
  *
  * @since 2.0.0
  * @category mutations
  */
-export declare const option: <R, E, A>(self: STM<R, E, A>) => STM<R, never, Option.Option<A>>;
+export declare const option: <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, never, R>;
 /**
  * Translates `STM` effect failure into death of the fiber, making all
  * failures unchecked and not a part of the type of the effect.
@@ -948,7 +948,7 @@ export declare const option: <R, E, A>(self: STM<R, E, A>) => STM<R, never, Opti
  * @since 2.0.0
  * @category error handling
  */
-export declare const orDie: <R, E, A>(self: STM<R, E, A>) => STM<R, never, A>;
+export declare const orDie: <A, E, R>(self: STM<A, E, R>) => STM<A, never, R>;
 /**
  * Keeps none of the errors, and terminates the fiber running the `STM` effect
  * with them, using the specified function to convert the `E` into a defect.
@@ -957,8 +957,8 @@ export declare const orDie: <R, E, A>(self: STM<R, E, A>) => STM<R, never, A>;
  * @category error handling
  */
 export declare const orDieWith: {
-    <E>(f: (error: E) => unknown): <R, A>(self: STM<R, E, A>) => STM<R, never, A>;
-    <R, A, E>(self: STM<R, E, A>, f: (error: E) => unknown): STM<R, never, A>;
+    <E>(f: (error: E) => unknown): <R, A>(self: STM<A, E, R>) => STM<A, never, R>;
+    <R, A, E>(self: STM<A, E, R>, f: (error: E) => unknown): STM<A, never, R>;
 };
 /**
  * Tries this effect first, and if it fails or retries, tries the other
@@ -968,8 +968,8 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<STM<R2, E2, A2>>): <R, E, A>(self: STM<R, E, A>) => STM<R2 | R, E2, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: STM<R, E, A>, that: LazyArg<STM<R2, E2, A2>>): STM<R | R2, E2, A | A2>;
+    <R2, E2, A2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, E2, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<A | A2, E2, R | R2>;
 };
 /**
  * Returns a transactional effect that will produce the value of this effect
@@ -980,8 +980,8 @@ export declare const orElse: {
  * @category error handling
  */
 export declare const orElseEither: {
-    <R2, E2, A2>(that: LazyArg<STM<R2, E2, A2>>): <R, E, A>(self: STM<R, E, A>) => STM<R2 | R, E2, Either.Either<A, A2>>;
-    <R, E, A, R2, E2, A2>(self: STM<R, E, A>, that: LazyArg<STM<R2, E2, A2>>): STM<R | R2, E2, Either.Either<A, A2>>;
+    <R2, E2, A2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<A, A2>, E2, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<Either.Either<A, A2>, E2, R | R2>;
 };
 /**
  * Tries this effect first, and if it fails or retries, fails with the
@@ -991,8 +991,8 @@ export declare const orElseEither: {
  * @category error handling
  */
 export declare const orElseFail: {
-    <E2>(error: LazyArg<E2>): <R, E, A>(self: STM<R, E, A>) => STM<R, E2, A>;
-    <R, E, A, E2>(self: STM<R, E, A>, error: LazyArg<E2>): STM<R, E2, A>;
+    <E2>(error: LazyArg<E2>): <A, E, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <R, E, A, E2>(self: STM<A, E, R>, error: LazyArg<E2>): STM<A, E2, R>;
 };
 /**
  * Returns an effect that will produce the value of this effect, unless it
@@ -1003,8 +1003,8 @@ export declare const orElseFail: {
  * @category error handling
  */
 export declare const orElseOptional: {
-    <R2, E2, A2>(that: LazyArg<STM<R2, Option.Option<E2>, A2>>): <R, E, A>(self: STM<R, Option.Option<E>, A>) => STM<R2 | R, Option.Option<E2 | E>, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: STM<R, Option.Option<E>, A>, that: LazyArg<STM<R2, Option.Option<E2>, A2>>): STM<R | R2, Option.Option<E | E2>, A | A2>;
+    <R2, E2, A2>(that: LazyArg<STM<A2, Option.Option<E2>, R2>>): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: STM<A, Option.Option<E>, R>, that: LazyArg<STM<A2, Option.Option<E2>, R2>>): STM<A | A2, Option.Option<E | E2>, R | R2>;
 };
 /**
  * Tries this effect first, and if it fails or retries, succeeds with the
@@ -1014,8 +1014,8 @@ export declare const orElseOptional: {
  * @category error handling
  */
 export declare const orElseSucceed: {
-    <A2>(value: LazyArg<A2>): <R, E, A>(self: STM<R, E, A>) => STM<R, never, A2 | A>;
-    <R, E, A, A2>(self: STM<R, E, A>, value: LazyArg<A2>): STM<R, never, A | A2>;
+    <A2>(value: LazyArg<A2>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, never, R>;
+    <R, E, A, A2>(self: STM<A, E, R>, value: LazyArg<A2>): STM<A | A2, never, R>;
 };
 /**
  * Tries this effect first, and if it enters retry, then it tries the other
@@ -1025,8 +1025,8 @@ export declare const orElseSucceed: {
  * @category error handling
  */
 export declare const orTry: {
-    <R1, E1, A1>(that: LazyArg<STM<R1, E1, A1>>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1 | A>;
-    <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: LazyArg<STM<R1, E1, A1>>): STM<R | R1, E | E1, A | A1>;
+    <R1, E1, A1>(that: LazyArg<STM<A1, E1, R1>>): <A, E, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | E, R1 | R>;
+    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: LazyArg<STM<A1, E1, R1>>): STM<A | A1, E | E1, R | R1>;
 };
 /**
  * Feeds elements of type `A` to a function `f` that returns an effect.
@@ -1036,8 +1036,8 @@ export declare const orTry: {
  * @category traversing
  */
 export declare const partition: {
-    <R, E, A, A2>(f: (a: A) => STM<R, E, A2>): (elements: Iterable<A>) => STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>;
-    <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>): STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>;
+    <R, E, A, A2>(f: (a: A) => STM<A2, E, R>): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
+    <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
 };
 /**
  * Provides the transaction its required environment, which eliminates its
@@ -1047,8 +1047,8 @@ export declare const partition: {
  * @category context
  */
 export declare const provideContext: {
-    <R>(env: Context.Context<R>): <E, A>(self: STM<R, E, A>) => STM<never, E, A>;
-    <E, A, R>(self: STM<R, E, A>, env: Context.Context<R>): STM<never, E, A>;
+    <R>(env: Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E>;
+    <A, E, R>(self: STM<A, E, R>, env: Context.Context<R>): STM<A, E>;
 };
 /**
  * Splits the context into two parts, providing one part using the
@@ -1058,8 +1058,8 @@ export declare const provideContext: {
  * @category context
  */
 export declare const provideSomeContext: {
-    <R>(context: Context.Context<R>): <R1, E, A>(self: STM<R1, E, A>) => STM<Exclude<R1, R>, E, A>;
-    <R, R1, E, A>(self: STM<R1, E, A>, context: Context.Context<R>): STM<Exclude<R1, R>, E, A>;
+    <R>(context: Context.Context<R>): <R1, E, A>(self: STM<A, E, R1>) => STM<A, E, Exclude<R1, R>>;
+    <R, R1, E, A>(self: STM<A, E, R1>, context: Context.Context<R>): STM<A, E, Exclude<R1, R>>;
 };
 /**
  * Provides the effect with the single service it requires. If the transactional
@@ -1069,8 +1069,8 @@ export declare const provideSomeContext: {
  * @category context
  */
 export declare const provideService: {
-    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <R, E, A>(self: STM<R, E, A>) => STM<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: STM<R, E, A>, tag: T, resource: Context.Tag.Service<T>): STM<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <R, E, A, T extends Context.Tag<any, any>>(self: STM<A, E, R>, tag: T, resource: Context.Tag.Service<T>): STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Provides the effect with the single service it requires. If the transactional
@@ -1080,8 +1080,8 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceSTM: {
-    <T extends Context.Tag<any, any>, R1, E1>(tag: T, stm: STM<R1, E1, Context.Tag.Service<T>>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>;
-    <R, E, A, T extends Context.Tag<any, any>, R1, E1>(self: STM<R, E, A>, tag: T, stm: STM<R1, E1, Context.Tag.Service<T>>): STM<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1, A>;
+    <T extends Context.Tag<any, any>, R1, E1>(tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <R, E, A, T extends Context.Tag<any, any>, R1, E1>(self: STM<A, E, R>, tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): STM<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially
@@ -1091,8 +1091,8 @@ export declare const provideServiceSTM: {
  * @category constructors
  */
 export declare const reduce: {
-    <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<R, E, S>): (iterable: Iterable<A>) => STM<R, E, S>;
-    <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<R, E, S>): STM<R, E, S>;
+    <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
+    <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
 };
 /**
  * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
@@ -1101,8 +1101,8 @@ export declare const reduce: {
  * @category constructors
  */
 export declare const reduceAll: {
-    <R2, E2, A>(initial: STM<R2, E2, A>, f: (x: A, y: A) => A): <R, E>(iterable: Iterable<STM<R, E, A>>) => STM<R2 | R, E2 | E, A>;
-    <R, E, R2, E2, A>(iterable: Iterable<STM<R, E, A>>, initial: STM<R2, E2, A>, f: (x: A, y: A) => A): STM<R | R2, E | E2, A>;
+    <R2, E2, A>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <R, E>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>;
+    <R, E, R2, E2, A>(iterable: Iterable<STM<A, E, R>>, initial: STM<A, E2, R2>, f: (x: A, y: A) => A): STM<A, E | E2, R | R2>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially
@@ -1112,8 +1112,8 @@ export declare const reduceAll: {
  * @category constructors
  */
 export declare const reduceRight: {
-    <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<R, E, S>): (iterable: Iterable<A>) => STM<R, E, S>;
-    <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<R, E, S>): STM<R, E, S>;
+    <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
+    <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest.
@@ -1122,8 +1122,8 @@ export declare const reduceRight: {
  * @category mutations
  */
 export declare const refineOrDie: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: STM<R, E, A>) => STM<R, E2, A>;
-    <R, A, E, E2>(self: STM<R, E, A>, pf: (error: E) => Option.Option<E2>): STM<R, E2, A>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <R, A, E, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>): STM<A, E2, R>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using the
@@ -1133,8 +1133,8 @@ export declare const refineOrDie: {
  * @category mutations
  */
 export declare const refineOrDieWith: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: STM<R, E, A>) => STM<R, E2, A>;
-    <R, A, E, E2>(self: STM<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): STM<R, E2, A>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: STM<A, E, R>) => STM<A, E2, R>;
+    <R, A, E, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): STM<A, E2, R>;
 };
 /**
  * Fail with the returned value if the `PartialFunction` matches, otherwise
@@ -1144,8 +1144,8 @@ export declare const refineOrDieWith: {
  * @category mutations
  */
 export declare const reject: {
-    <A, E2>(pf: (a: A) => Option.Option<E2>): <R, E>(self: STM<R, E, A>) => STM<R, E2 | E, A>;
-    <R, E, A, E2>(self: STM<R, E, A>, pf: (a: A) => Option.Option<E2>): STM<R, E | E2, A>;
+    <A, E2>(pf: (a: A) => Option.Option<E2>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    <R, E, A, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<E2>): STM<A, E | E2, R>;
 };
 /**
  * Continue with the returned computation if the specified partial function
@@ -1156,8 +1156,8 @@ export declare const reject: {
  * @category mutations
  */
 export declare const rejectSTM: {
-    <A, R2, E2>(pf: (a: A) => Option.Option<STM<R2, E2, E2>>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: STM<R, E, A>, pf: (a: A) => Option.Option<STM<R2, E2, E2>>): STM<R | R2, E | E2, A>;
+    <A, R2, E2>(pf: (a: A) => Option.Option<STM<E2, E2, R2>>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    <R, E, A, R2, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<E2, E2, R2>>): STM<A, E | E2, R | R2>;
 };
 /**
  * Repeats this `STM` effect until its result satisfies the specified
@@ -1175,8 +1175,8 @@ export declare const rejectSTM: {
  * @category mutations
  */
 export declare const repeatUntil: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>): STM<R, E, A>;
+    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
  * Repeats this `STM` effect while its result satisfies the specified
@@ -1195,8 +1195,8 @@ export declare const repeatUntil: {
  * @category mutations
  */
 export declare const repeatWhile: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>): STM<R, E, A>;
+    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
  * Replicates the given effect n times. If 0 or negative numbers are given, an
@@ -1206,8 +1206,8 @@ export declare const repeatWhile: {
  * @category constructors
  */
 export declare const replicate: {
-    (n: number): <R, E, A>(self: STM<R, E, A>) => Array<STM<R, E, A>>;
-    <R, E, A>(self: STM<R, E, A>, n: number): Array<STM<R, E, A>>;
+    (n: number): <A, E, R>(self: STM<A, E, R>) => Array<STM<A, E, R>>;
+    <A, E, R>(self: STM<A, E, R>, n: number): Array<STM<A, E, R>>;
 };
 /**
  * Performs this transaction the specified number of times and collects the
@@ -1217,8 +1217,8 @@ export declare const replicate: {
  * @category constructors
  */
 export declare const replicateSTM: {
-    (n: number): <R, E, A>(self: STM<R, E, A>) => STM<R, E, Array<A>>;
-    <R, E, A>(self: STM<R, E, A>, n: number): STM<R, E, Array<A>>;
+    (n: number): <A, E, R>(self: STM<A, E, R>) => STM<Array<A>, E, R>;
+    <A, E, R>(self: STM<A, E, R>, n: number): STM<Array<A>, E, R>;
 };
 /**
  * Performs this transaction the specified number of times, discarding the
@@ -1228,8 +1228,8 @@ export declare const replicateSTM: {
  * @category constructors
  */
 export declare const replicateSTMDiscard: {
-    (n: number): <R, E, A>(self: STM<R, E, A>) => STM<R, E, void>;
-    <R, E, A>(self: STM<R, E, A>, n: number): STM<R, E, void>;
+    (n: number): <A, E, R>(self: STM<A, E, R>) => STM<void, E, R>;
+    <A, E, R>(self: STM<A, E, R>, n: number): STM<void, E, R>;
 };
 /**
  * Abort and retry the whole transaction when any of the underlying
@@ -1238,7 +1238,7 @@ export declare const replicateSTMDiscard: {
  * @since 2.0.0
  * @category error handling
  */
-export declare const retry: STM<never, never, never>;
+export declare const retry: STM<never>;
 /**
  * Filters the value produced by this effect, retrying the transaction until
  * the predicate returns `true` for the value.
@@ -1247,10 +1247,10 @@ export declare const retry: STM<never, never, never>;
  * @category mutations
  */
 export declare const retryUntil: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>): STM<R, E, B>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>): STM<R, E, A>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM<A, E, R>) => STM<B, E, R>;
+    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <R, E, A, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>): STM<B, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
  * Filters the value produced by this effect, retrying the transaction while
@@ -1260,8 +1260,8 @@ export declare const retryUntil: {
  * @category mutations
  */
 export declare const retryWhile: {
-    <A>(predicate: Predicate<A>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>;
-    <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>): STM<R, E, A>;
+    <A>(predicate: Predicate<A>): <R, E>(self: STM<A, E, R>) => STM<A, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
  * Converts an option on values into an option on errors.
@@ -1269,28 +1269,28 @@ export declare const retryWhile: {
  * @since 2.0.0
  * @category getters
  */
-export declare const some: <R, E, A>(self: STM<R, E, Option.Option<A>>) => STM<R, Option.Option<E>, A>;
+export declare const some: <A, E, R>(self: STM<Option.Option<A>, E, R>) => STM<A, Option.Option<E>, R>;
 /**
  * Returns an `STM` effect that succeeds with the specified value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <A>(value: A) => STM<never, never, A>;
+export declare const succeed: <A>(value: A) => STM<A>;
 /**
  * Returns an effect with the empty value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeedNone: STM<never, never, Option.Option<never>>;
+export declare const succeedNone: STM<Option.Option<never>>;
 /**
  * Returns an effect with the optional value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeedSome: <A>(value: A) => STM<never, never, Option.Option<A>>;
+export declare const succeedSome: <A>(value: A) => STM<Option.Option<A>>;
 /**
  * Summarizes a `STM` effect by computing a provided value before and after
  * execution, and then combining the values to produce a summary, together
@@ -1300,8 +1300,8 @@ export declare const succeedSome: <A>(value: A) => STM<never, never, Option.Opti
  * @category mutations
  */
 export declare const summarized: {
-    <R2, E2, A2, A3>(summary: STM<R2, E2, A2>, f: (before: A2, after: A2) => A3): <R, E, A>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, [A3, A]>;
-    <R, E, A, R2, E2, A2, A3>(self: STM<R, E, A>, summary: STM<R2, E2, A2>, f: (before: A2, after: A2) => A3): STM<R | R2, E | E2, [A3, A]>;
+    <R2, E2, A2, A3>(summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>;
+    <R, E, A, R2, E2, A2, A3>(self: STM<A, E, R>, summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): STM<[A3, A], E | E2, R | R2>;
 };
 /**
  * Suspends creation of the specified transaction lazily.
@@ -1309,7 +1309,7 @@ export declare const summarized: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const suspend: <R, E, A>(evaluate: LazyArg<STM<R, E, A>>) => STM<R, E, A>;
+export declare const suspend: <A, E, R>(evaluate: LazyArg<STM<A, E, R>>) => STM<A, E, R>;
 /**
  * Returns an `STM` effect that succeeds with the specified lazily evaluated
  * value.
@@ -1317,7 +1317,7 @@ export declare const suspend: <R, E, A>(evaluate: LazyArg<STM<R, E, A>>) => STM<
  * @since 2.0.0
  * @category constructors
  */
-export declare const sync: <A>(evaluate: () => A) => STM<never, never, A>;
+export declare const sync: <A>(evaluate: () => A) => STM<A>;
 /**
  * "Peeks" at the success of transactional effect.
  *
@@ -1325,8 +1325,8 @@ export declare const sync: <A>(evaluate: () => A) => STM<never, never, A>;
  * @category sequencing
  */
 export declare const tap: {
-    <A, R2, E2, _>(f: (a: A) => STM<R2, E2, _>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, _>(self: STM<R, E, A>, f: (a: A) => STM<R2, E2, _>): STM<R | R2, E | E2, A>;
+    <A, R2, E2, _>(f: (a: A) => STM<_, E2, R2>): <R, E>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    <R, E, A, R2, E2, _>(self: STM<A, E, R>, f: (a: A) => STM<_, E2, R2>): STM<A, E | E2, R | R2>;
 };
 /**
  * "Peeks" at both sides of an transactional effect.
@@ -1336,13 +1336,13 @@ export declare const tap: {
  */
 export declare const tapBoth: {
     <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(options: {
-        readonly onFailure: (error: XE) => STM<R2, E2, A2>;
-        readonly onSuccess: (value: XA) => STM<R3, E3, A3>;
-    }): <R>(self: STM<R, E, A>) => STM<R2 | R3 | R, E | E2 | E3, A>;
-    <R, E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(self: STM<R, E, A>, options: {
-        readonly onFailure: (error: XE) => STM<R2, E2, A2>;
-        readonly onSuccess: (value: XA) => STM<R3, E3, A3>;
-    }): STM<R | R2 | R3, E | E2 | E3, A>;
+        readonly onFailure: (error: XE) => STM<A2, E2, R2>;
+        readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
+    }): <R>(self: STM<A, E, R>) => STM<A, E | E2 | E3, R2 | R3 | R>;
+    <R, E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(self: STM<A, E, R>, options: {
+        readonly onFailure: (error: XE) => STM<A2, E2, R2>;
+        readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
+    }): STM<A, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * "Peeks" at the error of the transactional effect.
@@ -1351,15 +1351,15 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, R2, E2, _>(f: (error: NoInfer<E>) => STM<R2, E2, _>): <R, A>(self: STM<R, E, A>) => STM<R2 | R, E | E2, A>;
-    <R, A, E, R2, E2, _>(self: STM<R, E, A>, f: (error: E) => STM<R2, E2, _>): STM<R | R2, E | E2, A>;
+    <E, R2, E2, _>(f: (error: NoInfer<E>) => STM<_, E2, R2>): <R, A>(self: STM<A, E, R>) => STM<A, E | E2, R2 | R>;
+    <R, A, E, R2, E2, _>(self: STM<A, E, R>, f: (error: E) => STM<_, E2, R2>): STM<A, E | E2, R | R2>;
 };
 declare const try_: {
     <A, E>(options: {
         readonly try: LazyArg<A>;
         readonly catch: (u: unknown) => E;
-    }): STM<never, E, A>;
-    <A>(try_: LazyArg<A>): STM<never, unknown, A>;
+    }): STM<A, E>;
+    <A>(try_: LazyArg<A>): STM<A, unknown>;
 };
 export { 
 /**
@@ -1377,8 +1377,8 @@ try_ as try };
  * @category mutations
  */
 export declare const unless: {
-    (predicate: LazyArg<boolean>): <R, E, A>(self: STM<R, E, A>) => STM<R, E, Option.Option<A>>;
-    <R, E, A>(self: STM<R, E, A>, predicate: LazyArg<boolean>): STM<R, E, Option.Option<A>>;
+    (predicate: LazyArg<boolean>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: LazyArg<boolean>): STM<Option.Option<A>, E, R>;
 };
 /**
  * The moral equivalent of `if (!p) exp` when `p` has side-effects
@@ -1387,8 +1387,8 @@ export declare const unless: {
  * @category mutations
  */
 export declare const unlessSTM: {
-    <R2, E2>(predicate: STM<R2, E2, boolean>): <R, E, A>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, Option.Option<A>>;
-    <R, E, A, R2, E2>(self: STM<R, E, A>, predicate: STM<R2, E2, boolean>): STM<R | R2, E | E2, Option.Option<A>>;
+    <R2, E2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    <R, E, A, R2, E2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
  * Converts an option on errors into an option on values.
@@ -1396,14 +1396,14 @@ export declare const unlessSTM: {
  * @since 2.0.0
  * @category getters
  */
-export declare const unsome: <R, E, A>(self: STM<R, Option.Option<E>, A>) => STM<R, E, Option.Option<A>>;
+export declare const unsome: <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<Option.Option<A>, E, R>;
 /**
  * Returns an `STM` effect that succeeds with `Unit`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unit: STM<never, never, void>;
+export declare const unit: STM<void>;
 /**
  * Feeds elements of type `A` to `f` and accumulates all errors in error
  * channel or successes in success channel.
@@ -1415,8 +1415,8 @@ export declare const unit: STM<never, never, void>;
  * @category mutations
  */
 export declare const validateAll: {
-    <R, E, A, B>(f: (a: A) => STM<R, E, B>): (elements: Iterable<A>) => STM<R, [E, ...Array<E>], Array<B>>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<R, E, B>): STM<R, [E, ...Array<E>], Array<B>>;
+    <R, E, A, B>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<Array<B>, [E, ...Array<E>], R>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<Array<B>, [E, ...Array<E>], R>;
 };
 /**
  * Feeds elements of type `A` to `f` until it succeeds. Returns first success
@@ -1426,8 +1426,8 @@ export declare const validateAll: {
  * @category mutations
  */
 export declare const validateFirst: {
-    <R, E, A, B>(f: (a: A) => STM<R, E, B>): (elements: Iterable<A>) => STM<R, Array<E>, B>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<R, E, B>): STM<R, Array<E>, B>;
+    <R, E, A, B>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<B, Array<E>, R>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<B, Array<E>, R>;
 };
 /**
  * The moral equivalent of `if (p) exp`.
@@ -1436,8 +1436,8 @@ export declare const validateFirst: {
  * @category mutations
  */
 export declare const when: {
-    (predicate: LazyArg<boolean>): <R, E, A>(self: STM<R, E, A>) => STM<R, E, Option.Option<A>>;
-    <R, E, A>(self: STM<R, E, A>, predicate: LazyArg<boolean>): STM<R, E, Option.Option<A>>;
+    (predicate: LazyArg<boolean>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E, R>;
+    <A, E, R>(self: STM<A, E, R>, predicate: LazyArg<boolean>): STM<Option.Option<A>, E, R>;
 };
 /**
  * The moral equivalent of `if (p) exp` when `p` has side-effects.
@@ -1446,8 +1446,8 @@ export declare const when: {
  * @category mutations
  */
 export declare const whenSTM: {
-    <R2, E2>(predicate: STM<R2, E2, boolean>): <R, E, A>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, Option.Option<A>>;
-    <R, E, A, R2, E2>(self: STM<R, E, A>, predicate: STM<R2, E2, boolean>): STM<R | R2, E | E2, Option.Option<A>>;
+    <R2, E2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    <R, E, A, R2, E2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
  * Sequentially zips this value with the specified one.
@@ -1456,8 +1456,8 @@ export declare const whenSTM: {
  * @category zipping
  */
 export declare const zip: {
-    <R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, [A, A1]>;
-    <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: STM<R1, E1, A1>): STM<R | R1, E | E1, [A, A1]>;
+    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<[A, A1], E1 | E, R1 | R>;
+    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<[A, A1], E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, discarding the second
@@ -1467,8 +1467,8 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
-    <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: STM<R1, E1, A1>): STM<R | R1, E | E1, A>;
+    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | R>;
+    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A, E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, discarding the first
@@ -1478,8 +1478,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1>;
-    <R, E, A, R1, E1, A1>(self: STM<R, E, A>, that: STM<R1, E1, A1>): STM<R | R1, E | E1, A1>;
+    <R1, E1, A1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A1, E1 | E, R1 | R>;
+    <R, E, A, R1, E1, A1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A1, E | E1, R | R1>;
 };
 /**
  * Sequentially zips this value with the specified one, combining the values
@@ -1489,8 +1489,8 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R1, E1, A1, A, A2>(that: STM<R1, E1, A1>, f: (a: A, b: A1) => A2): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2>;
-    <R, E, R1, E1, A1, A, A2>(self: STM<R, E, A>, that: STM<R1, E1, A1>, f: (a: A, b: A1) => A2): STM<R | R1, E | E1, A2>;
+    <R1, E1, A1, A, A2>(that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): <R, E>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    <R, E, R1, E1, A1, A, A2>(self: STM<A, E, R>, that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): STM<A2, E | E1, R | R1>;
 };
 /**
  * This function takes an iterable of `STM` values and returns a new
@@ -1511,31 +1511,31 @@ export declare const zipWith: {
  * @since 2.0.0
  * @category elements
  */
-export declare const firstSuccessOf: <R, E, A>(effects: Iterable<STM<R, E, A>>) => STM<R, E, A>;
+export declare const firstSuccessOf: <A, E, R>(effects: Iterable<STM<A, E, R>>) => STM<A, E, R>;
 /**
  * @category do notation
  * @since 2.0.0
  */
-export declare const Do: STM<never, never, {}>;
+export declare const Do: STM<{}>;
 /**
  * @category do notation
  * @since 2.0.0
  */
 export declare const bind: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => STM<R2, E2, A>): <R, E>(self: STM<R, E, K>) => STM<R2 | R, E2 | E, Effect.MergeRecord<K, {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): <R, E>(self: STM<K, E, R>) => STM<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, N extends string, K, R2, E2, A>(self: STM<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => STM<R2, E2, A>): STM<R | R2, E | E2, Effect.MergeRecord<K, {
+    }>, E2 | E, R2 | R>;
+    <R, E, N extends string, K, R2, E2, A>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): STM<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E | E2, R | R2>;
 };
 declare const let_: {
-    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: STM<R, E, K>) => STM<R, E, Effect.MergeRecord<K, {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: STM<K, E, R>) => STM<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, K, N extends string, A>(self: STM<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): STM<R, E, Effect.MergeRecord<K, {
+    }>, E, R>;
+    <R, E, K, N extends string, A>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): STM<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E, R>;
 };
 export { 
 /**
@@ -1548,7 +1548,7 @@ let_ as let };
  * @since 2.0.0
  */
 export declare const bindTo: {
-    <N extends string>(tag: N): <R, E, A>(self: STM<R, E, A>) => STM<R, E, Record<N, A>>;
-    <R, E, A, N extends string>(self: STM<R, E, A>, tag: N): STM<R, E, Record<N, A>>;
+    <N extends string>(tag: N): <A, E, R>(self: STM<A, E, R>) => STM<Record<N, A>, E, R>;
+    <R, E, A, N extends string>(self: STM<A, E, R>, tag: N): STM<Record<N, A>, E, R>;
 };
 //# sourceMappingURL=STM.d.ts.map