effect 2.2.5 → 2.3.1

package/dist/dts/Effect.d.ts

@@ -10,7 +10,6 @@ import type * as Context from "./Context.js";
 import type * as Deferred from "./Deferred.js";
 import type * as Duration from "./Duration.js";
 import type * as Either from "./Either.js";
-import type * as Equal from "./Equal.js";
 import type { Equivalence } from "./Equivalence.js";
 import type { ExecutionStrategy } from "./ExecutionStrategy.js";
 import type * as Exit from "./Exit.js";
@@ -77,7 +76,7 @@ export type EffectTypeId = typeof EffectTypeId;
  * @since 2.0.0
  * @category models
  */
-export interface Effect<out R, out E, out A> extends Effect.Variance<R, E, A>, Equal.Equal, Pipeable {
+export interface Effect<out A, out E = never, out R = never> extends Effect.Variance<A, E, R>, Pipeable {
     readonly [Unify.typeSymbol]?: unknown;
     readonly [Unify.unifySymbol]?: EffectUnify<this>;
     readonly [Unify.ignoreSymbol]?: EffectUnifyIgnore;
@@ -89,7 +88,7 @@ export interface Effect<out R, out E, out A> extends Effect.Variance<R, E, A>, E
 export interface EffectUnify<A extends {
     [Unify.typeSymbol]?: any;
 }> extends Either.EitherUnify<A>, Option.OptionUnify<A>, Context.TagUnify<A> {
-    Effect?: () => A[Unify.typeSymbol] extends Effect<infer R0, infer E0, infer A0> | infer _ ? Effect<R0, E0, A0> : never;
+    Effect?: () => A[Unify.typeSymbol] extends Effect<infer A0, infer E0, infer R0> | infer _ ? Effect<A0, E0, R0> : never;
 }
 /**
  * @category models
@@ -105,23 +104,23 @@ export interface EffectUnifyIgnore {
  * @since 2.0.0
  */
 export interface EffectTypeLambda extends TypeLambda {
-    readonly type: Effect<this["Out2"], this["Out1"], this["Target"]>;
+    readonly type: Effect<this["Target"], this["Out1"], this["Out2"]>;
 }
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Blocked<out E, out A> extends Effect<never, E, A> {
+export interface Blocked<out A, out E> extends Effect<A, E> {
     readonly _op: "Blocked";
     readonly i0: RequestBlock;
-    readonly i1: Effect<never, E, A>;
+    readonly i1: Effect<A, E>;
 }
 /**
  * @since 2.0.0
  * @category models
  */
 declare module "./Context.js" {
-    interface Tag<Identifier, Service> extends Effect<Identifier, never, Service> {
+    interface Tag<Identifier, Service> extends Effect<Service, never, Identifier> {
     }
     interface TagUnifyIgnore {
         Effect?: true;
@@ -134,10 +133,10 @@ declare module "./Context.js" {
  * @category models
  */
 declare module "./Either.js" {
-    interface Left<E, A> extends Effect<never, E, A> {
+    interface Left<E, A> extends Effect<A, E> {
         readonly _tag: "Left";
     }
-    interface Right<E, A> extends Effect<never, E, A> {
+    interface Right<E, A> extends Effect<A, E> {
         readonly _tag: "Right";
     }
     interface EitherUnifyIgnore {
@@ -151,10 +150,10 @@ declare module "./Either.js" {
  * @category models
  */
 declare module "./Option.js" {
-    interface None<A> extends Effect<never, Cause.NoSuchElementException, A> {
+    interface None<A> extends Effect<A, Cause.NoSuchElementException> {
         readonly _tag: "None";
     }
-    interface Some<A> extends Effect<never, Cause.NoSuchElementException, A> {
+    interface Some<A> extends Effect<A, Cause.NoSuchElementException> {
         readonly _tag: "Some";
     }
     interface OptionUnifyIgnore {
@@ -171,39 +170,39 @@ export declare namespace Effect {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out R, out E, out A> {
-        readonly [EffectTypeId]: VarianceStruct<R, E, A>;
+    interface Variance<out A, out E, out R> {
+        readonly [EffectTypeId]: VarianceStruct<A, E, R>;
     }
     /**
      * @since 2.0.0
      * @category models
      */
-    interface VarianceStruct<out R, out E, out A> {
+    interface VarianceStruct<out A, out E, out R> {
         readonly _V: string;
-        readonly _R: Covariant<R>;
-        readonly _E: Covariant<E>;
         readonly _A: Covariant<A>;
+        readonly _E: Covariant<E>;
+        readonly _R: Covariant<R>;
     }
     /**
      * @since 2.0.0
      * @category models
      */
-    type Unify<Ret extends Effect<any, any, any>> = Effect<Context<Ret>, Error<Ret>, Success<Ret>>;
+    type Unify<Ret extends Effect<any, any, any>> = Effect<Success<Ret>, Error<Ret>, Context<Ret>>;
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Context<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _R : never;
+    type Context<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _R : never;
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Error<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _E : never;
+    type Error<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _E : never;
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Success<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _A : never;
+    type Success<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _A : never;
 }
 /**
  * This function returns `true` if the specified value is an `Effect` value,
@@ -231,8 +230,8 @@ export declare const isEffect: (u: unknown) => u is Effect<unknown, unknown, unk
  * @category caching
  */
 export declare const cachedWithTTL: {
-    (timeToLive: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Effect<never, E, A>>;
-    <R, E, A>(self: Effect<R, E, A>, timeToLive: Duration.DurationInput): Effect<R, never, Effect<never, E, A>>;
+    (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E>, never, R>;
+    <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<Effect<A, E>, never, R>;
 };
 /**
  * Returns an effect that, if evaluated, will return the cached result of this
@@ -244,8 +243,8 @@ export declare const cachedWithTTL: {
  * @category caching
  */
 export declare const cachedInvalidateWithTTL: {
-    (timeToLive: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, [Effect<never, E, A>, Effect<never, never, void>]>;
-    <R, E, A>(self: Effect<R, E, A>, timeToLive: Duration.DurationInput): Effect<R, never, [Effect<never, E, A>, Effect<never, never, void>]>;
+    (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E>, Effect<void>], never, R>;
+    <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<[Effect<A, E>, Effect<void>], never, R>;
 };
 /**
  * Returns an effect that, if evaluated, will return the lazily computed
@@ -254,14 +253,14 @@ export declare const cachedInvalidateWithTTL: {
  * @since 2.0.0
  * @category caching
  */
-export declare const cached: <R, E, A>(self: Effect<R, E, A>) => Effect<never, never, Effect<R, E, A>>;
+export declare const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>;
 /**
  * Returns a memoized version of the specified effectual function.
  *
  * @since 2.0.0
  * @category caching
  */
-export declare const cachedFunction: <R, E, A, B>(f: (a: A) => Effect<R, E, B>, eq?: Equivalence<A>) => Effect<never, never, (a: A) => Effect<R, E, B>>;
+export declare const cachedFunction: <A, B, E, R>(f: (a: A) => Effect<B, E, R>, eq?: Equivalence<A>) => Effect<(a: A) => Effect<B, E, R>>;
 /**
  * Returns an effect that will be executed at most once, even if it is
  * evaluated multiple times.
@@ -286,7 +285,7 @@ export declare const cachedFunction: <R, E, A, B>(f: (a: A) => Effect<R, E, B>,
  * @since 2.0.0
  * @category caching
  */
-export declare const once: <R, E, A>(self: Effect<R, E, A>) => Effect<never, never, Effect<R, E, void>>;
+export declare const once: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<void, E, R>>;
 /**
  * Runs all the provided effects in sequence respecting the structure provided in input.
  *
@@ -329,46 +328,46 @@ export declare namespace All {
      * @since 2.0.0
      */
     type ReturnIterable<T extends Iterable<EffectAny>, Discard extends boolean, Mode> = [T] extends [
-        Iterable<Effect.Variance<infer R, infer E, infer A>>
-    ] ? Effect<R, Mode extends "either" ? never : Mode extends "validate" ? Array<Option.Option<E>> : E, Discard extends true ? void : Mode extends "either" ? Array<Either.Either<E, A>> : Array<A>> : never;
+        Iterable<Effect.Variance<infer A, infer E, infer R>>
+    ] ? Effect<Discard extends true ? void : Mode extends "either" ? Array<Either.Either<E, A>> : Array<A>, Mode extends "either" ? never : Mode extends "validate" ? Array<Option.Option<E>> : E, R> : never;
     /**
      * @since 2.0.0
      */
-    type ReturnTuple<T extends ReadonlyArray<unknown>, Discard extends boolean, Mode> = Effect<T[number] extends never ? never : [T[number]] extends [{
-        [EffectTypeId]: {
-            _R: (_: never) => infer R;
-        };
-    }] ? R : never, Mode extends "either" ? never : T[number] extends never ? never : Mode extends "validate" ? {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Option.Option<_E> : never;
+    type ReturnTuple<T extends ReadonlyArray<unknown>, Discard extends boolean, Mode> = Effect<Discard extends true ? void : T[number] extends never ? [] : Mode extends "either" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? Either.Either<_E, _A> : never;
+    } : {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? _A : never;
+    }, Mode extends "either" ? never : T[number] extends never ? never : Mode extends "validate" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? Option.Option<_E> : never;
     } : [T[number]] extends [{
         [EffectTypeId]: {
             _E: (_: never) => infer E;
         };
-    }] ? E : never, Discard extends true ? void : T[number] extends never ? [] : Mode extends "either" ? {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Either.Either<_E, _A> : never;
-    } : {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? _A : never;
-    }> extends infer X ? X : never;
+    }] ? E : never, T[number] extends never ? never : [T[number]] extends [{
+        [EffectTypeId]: {
+            _R: (_: never) => infer R;
+        };
+    }] ? R : never> extends infer X ? X : never;
     /**
      * @since 2.0.0
      */
     type ReturnObject<T, Discard extends boolean, Mode> = [T] extends [{
         [K: string]: EffectAny;
-    }] ? Effect<keyof T extends never ? never : [T[keyof T]] extends [{
-        [EffectTypeId]: {
-            _R: (_: never) => infer R;
-        };
-    }] ? R : never, Mode extends "either" ? never : keyof T extends never ? never : Mode extends "validate" ? {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Option.Option<_E> : never;
+    }] ? Effect<Discard extends true ? void : Mode extends "either" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? Either.Either<_E, _A> : never;
+    } : {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? _A : never;
+    }, Mode extends "either" ? never : keyof T extends never ? never : Mode extends "validate" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _A, infer _E, infer _R>] ? Option.Option<_E> : never;
     } : [T[keyof T]] extends [{
         [EffectTypeId]: {
             _E: (_: never) => infer E;
         };
-    }] ? E : never, Discard extends true ? void : Mode extends "either" ? {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Either.Either<_E, _A> : never;
-    } : {
-        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? _A : never;
-    }> : never;
+    }] ? E : never, keyof T extends never ? never : [T[keyof T]] extends [{
+        [EffectTypeId]: {
+            _R: (_: never) => infer R;
+        };
+    }] ? R : never> : never;
     /**
      * @since 2.0.0
      */
@@ -398,10 +397,10 @@ export declare namespace All {
  * @since 2.0.0
  * @category collecting & elements
  */
-export declare const allSuccesses: <R, E, A>(elements: Iterable<Effect<R, E, A>>, options?: {
+export declare const allSuccesses: <A, E, R>(elements: Iterable<Effect<A, E, R>>, options?: {
     readonly concurrency?: Concurrency | undefined;
     readonly batching?: boolean | "inherit" | undefined;
-}) => Effect<R, never, Array<A>>;
+} | undefined) => Effect<Array<A>, never, R>;
 /**
  * Drops all elements until the effectful predicate returns true.
  *
@@ -409,8 +408,8 @@ export declare const allSuccesses: <R, E, A>(elements: Iterable<Effect<R, E, A>>
  * @category collecting & elements
  */
 export declare const dropUntil: {
-    <A, R, E>(predicate: (a: NoInfer<A>, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
-    <A, R, E>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+    <A, E, R>(predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<boolean, E, R>): Effect<Array<A>, E, R>;
 };
 /**
  * Drops all elements so long as the predicate returns true.
@@ -419,8 +418,8 @@ export declare const dropUntil: {
  * @category collecting & elements
  */
 export declare const dropWhile: {
-    <A, R, E>(predicate: (a: NoInfer<A>, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
-    <A, R, E>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+    <A, E, R>(predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<boolean, E, R>): Effect<Array<A>, E, R>;
 };
 /**
  * Determines whether all elements of the `Collection<A>` satisfies the effectual
@@ -430,8 +429,8 @@ export declare const dropWhile: {
  * @category collecting & elements
  */
 export declare const every: {
-    <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, boolean>;
-    <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, boolean>;
+    <A, E, R>(f: (a: A, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<boolean, E, R>;
+    <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<boolean, E, R>): Effect<boolean, E, R>;
 };
 /**
  * Determines whether any element of the `Iterable<A>` satisfies the effectual
@@ -441,14 +440,14 @@ export declare const every: {
  * @category collecting & elements
  */
 export declare const exists: {
-    <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+    <A, E, R>(f: (a: A, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): (elements: Iterable<A>) => Effect<R, E, boolean>;
-    <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+    } | undefined): (elements: Iterable<A>) => Effect<boolean, E, R>;
+    <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R, E, boolean>;
+    } | undefined): Effect<boolean, E, R>;
 };
 /**
  * Filters the collection using the specified effectful predicate.
@@ -457,16 +456,16 @@ export declare const exists: {
  * @category collecting & elements
  */
 export declare const filter: {
-    <A, R, E>(f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+    <A, E, R>(f: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly negate?: boolean | undefined;
-    }): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
-    <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+    } | undefined): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly negate?: boolean | undefined;
-    }): Effect<R, E, Array<A>>;
+    } | undefined): Effect<Array<A>, E, R>;
 };
 /**
  * Returns the first element that satisfies the effectful predicate.
@@ -475,8 +474,8 @@ export declare const filter: {
  * @category collecting & elements
  */
 export declare const findFirst: {
-    <A, R, E>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Option.Option<A>>;
-    <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Option.Option<A>>;
+    <A, E, R>(f: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Option.Option<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): Effect<Option.Option<A>, E, R>;
 };
 /**
  * This function takes an iterable of `Effect` values and returns a new
@@ -497,32 +496,32 @@ export declare const findFirst: {
  * @since 2.0.0
  * @category collecting & elements
  */
-export declare const firstSuccessOf: <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
+export declare const firstSuccessOf: <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category collecting & elements
  */
 export declare const forEach: {
-    <A, R, E, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): (self: Iterable<A>) => Effect<R, E, Array<B>>;
-    <A, R, E, B>(f: (a: A, i: number) => Effect<R, E, B>, options: {
+    } | undefined): (self: Iterable<A>) => Effect<Array<B>, E, R>;
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): (self: Iterable<A>) => Effect<R, E, void>;
-    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    }): (self: Iterable<A>) => Effect<void, E, R>;
+    <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): Effect<R, E, Array<B>>;
-    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options: {
+    } | undefined): Effect<Array<B>, E, R>;
+    <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): Effect<R, E, void>;
+    }): Effect<void, E, R>;
 };
 /**
  * Returns a successful effect with the head of the collection if the collection
@@ -531,9 +530,9 @@ export declare const forEach: {
  * @since 2.0.0
  * @category collecting & elements
  */
-export declare const head: <R, E, A>(self: Effect<R, E, Iterable<A>>) => Effect<R, E | Cause.NoSuchElementException, A>;
+export declare const head: <A, E, R>(self: Effect<Iterable<A>, E, R>) => Effect<A, Cause.NoSuchElementException | E, R>;
 /**
- * Merges an `Iterable<Effect<R, E, A>>` to a single effect, working
+ * Merges an `Iterable<Effect<A, E, R>>` to a single effect, working
  * sequentially.
  *
  * @since 2.0.0
@@ -543,11 +542,11 @@ export declare const mergeAll: {
     <Z, A>(zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E>(elements: Iterable<Effect<R, E, A>>) => Effect<R, E, Z>;
-    <R, E, A, Z>(elements: Iterable<Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
+    } | undefined): <E, R>(elements: Iterable<Effect<A, E, R>>) => Effect<Z, E, R>;
+    <A, E, R, Z>(elements: Iterable<Effect<A, E, R>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R, E, Z>;
+    } | undefined): Effect<Z, E, R>;
 };
 /**
  * Feeds elements of type `A` to a function `f` that returns an effect.
@@ -557,14 +556,14 @@ export declare const mergeAll: {
  * @category collecting & elements
  */
 export declare const partition: {
-    <R, E, A, B>(f: (a: A) => Effect<R, E, B>, options?: {
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): (elements: Iterable<A>) => Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => Effect<R, E, B>, options?: {
+    } | undefined): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>;
+    } | undefined): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially
@@ -574,24 +573,24 @@ export declare const partition: {
  * @category collecting & elements
  */
 export declare const reduce: {
-    <Z, A, R, E>(zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, Z>): (elements: Iterable<A>) => Effect<R, E, Z>;
-    <Z, A, R, E>(elements: Iterable<A>, zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, Z>): Effect<R, E, Z>;
+    <Z, A, E, R>(zero: Z, f: (z: Z, a: A, i: number) => Effect<Z, E, R>): (elements: Iterable<A>) => Effect<Z, E, R>;
+    <A, Z, E, R>(elements: Iterable<A>, zero: Z, f: (z: Z, a: A, i: number) => Effect<Z, E, R>): Effect<Z, E, R>;
 };
 /**
- * Reduces an `Iterable<Effect<R, E, A>>` to a single effect.
+ * Reduces an `Iterable<Effect<A, E, R>>` to a single effect.
  *
  * @since 2.0.0
  * @category collecting & elements
  */
 export declare const reduceEffect: {
-    <R, E, A>(zero: Effect<R, E, A>, f: (acc: A, a: A, i: number) => A, options?: {
+    <A, E, R>(zero: Effect<A, E, R>, f: (acc: NoInfer<A>, a: NoInfer<A>, i: number) => A, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): (elements: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
-    <R, E, A>(elements: Iterable<Effect<R, E, A>>, zero: Effect<R, E, A>, f: (acc: A, a: A, i: number) => A, options?: {
+    }): (elements: Iterable<Effect<A, E, R>>) => Effect<A, E, R>;
+    <A, E, R>(elements: Iterable<Effect<A, E, R>>, zero: Effect<A, E, R>, f: (acc: NoInfer<A>, a: NoInfer<A>, i: number) => A, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R, E, A>;
+    }): Effect<A, E, R>;
 };
 /**
  * Folds an `Iterable<A>` using an effectual function f, working sequentially from left to right.
@@ -600,8 +599,8 @@ export declare const reduceEffect: {
  * @category collecting & elements
  */
 export declare const reduceRight: {
-    <A, Z, R, E>(zero: Z, f: (a: A, z: Z, i: number) => Effect<R, E, Z>): (elements: Iterable<A>) => Effect<R, E, Z>;
-    <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect<R, E, Z>): Effect<R, E, Z>;
+    <A, Z, R, E>(zero: Z, f: (a: A, z: Z, i: number) => Effect<Z, E, R>): (elements: Iterable<A>) => Effect<Z, E, R>;
+    <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect<Z, E, R>): Effect<Z, E, R>;
 };
 /**
  * Folds over the elements in this chunk from the left, stopping the fold early
@@ -613,12 +612,12 @@ export declare const reduceRight: {
 export declare const reduceWhile: {
     <A, R, E, Z>(zero: Z, options: {
         readonly while: Predicate<Z>;
-        readonly body: (s: Z, a: A, i: number) => Effect<R, E, Z>;
-    }): (elements: Iterable<A>) => Effect<R, E, Z>;
+        readonly body: (s: Z, a: A, i: number) => Effect<Z, E, R>;
+    }): (elements: Iterable<A>) => Effect<Z, E, R>;
     <A, R, E, Z>(elements: Iterable<A>, zero: Z, options: {
         readonly while: Predicate<Z>;
-        readonly body: (s: Z, a: A, i: number) => Effect<R, E, Z>;
-    }): Effect<R, E, Z>;
+        readonly body: (s: Z, a: A, i: number) => Effect<Z, E, R>;
+    }): Effect<Z, E, R>;
 };
 /**
  * Replicates the given effect `n` times.
@@ -627,8 +626,8 @@ export declare const reduceWhile: {
  * @category collecting & elements
  */
 export declare const replicate: {
-    (n: number): <R, E, A>(self: Effect<R, E, A>) => Array<Effect<R, E, A>>;
-    <R, E, A>(self: Effect<R, E, A>, n: number): Array<Effect<R, E, A>>;
+    (n: number): <A, E, R>(self: Effect<A, E, R>) => Array<Effect<A, E, R>>;
+    <A, E, R>(self: Effect<A, E, R>, n: number): Array<Effect<A, E, R>>;
 };
 /**
  * Performs this effect the specified number of times and collects the
@@ -642,22 +641,22 @@ export declare const replicateEffect: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Array<A>>;
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<Array<A>, E, R>;
     (n: number, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, void>;
-    <R, E, A>(self: Effect<R, E, A>, n: number, options?: {
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, n: number, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): Effect<R, E, Array<A>>;
-    <R, E, A>(self: Effect<R, E, A>, n: number, options: {
+    }): Effect<Array<A>, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, n: number, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): Effect<R, E, void>;
+    }): Effect<void, E, R>;
 };
 /**
  * Takes elements until the effectual predicate returns true.
@@ -666,8 +665,8 @@ export declare const replicateEffect: {
  * @category collecting & elements
  */
 export declare const takeUntil: {
-    <A, R, E>(predicate: (a: NoInfer<A>, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
-    <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+    <A, R, E>(predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): Effect<Array<A>, E, R>;
 };
 /**
  * Takes all elements so long as the effectual predicate returns true.
@@ -676,8 +675,8 @@ export declare const takeUntil: {
  * @category collecting & elements
  */
 export declare const takeWhile: {
-    <R, E, A>(predicate: (a: NoInfer<A>, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
-    <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+    <A, E, R>(predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Array<A>, E, R>;
+    <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): Effect<Array<A>, E, R>;
 };
 /**
  * Feeds elements of type `A` to `f` and accumulates all errors in error
@@ -690,26 +689,26 @@ export declare const takeWhile: {
  * @category collecting & elements
  */
 export declare const validateAll: {
-    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): (elements: Iterable<A>) => Effect<R, Array<E>, Array<B>>;
-    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options: {
+    } | undefined): (elements: Iterable<A>) => Effect<Array<B>, Array<E>, R>;
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): (elements: Iterable<A>) => Effect<R, Array<E>, void>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    }): (elements: Iterable<A>) => Effect<void, Array<E>, R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard?: false | undefined;
-    }): Effect<R, Array<E>, Array<B>>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options: {
+    } | undefined): Effect<Array<B>, Array<E>, R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
         readonly discard: true;
-    }): Effect<R, Array<E>, void>;
+    }): Effect<void, Array<E>, R>;
 };
 /**
  * Feeds elements of type `A` to `f` until it succeeds. Returns first success
@@ -733,18 +732,18 @@ export declare const validateAll: {
  * @category collecting & elements
  */
 export declare const validateFirst: {
-    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    <A, B, E, R>(f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): (elements: Iterable<A>) => Effect<R, Array<E>, B>;
-    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+    } | undefined): (elements: Iterable<A>) => Effect<B, Array<E>, R>;
+    <A, B, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect<B, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R, Array<E>, B>;
+    } | undefined): Effect<B, Array<E>, R>;
 };
 /**
  * Imports an asynchronous side-effect into a pure `Effect` value.
- * The callback function `Effect<R, E, A> => void` must be called at most once.
+ * The callback function `Effect<A, E, R> => void` must be called at most once.
  *
  * If an Effect is returned by the registration function, it will be executed
  * if the fiber executing the effect is interrupted.
@@ -758,7 +757,7 @@ export declare const validateFirst: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const async: <R, E, A>(register: (callback: (_: Effect<R, E, A>) => void, signal: AbortSignal) => void | Effect<R, never, void>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+export declare const async: <A, E = never, R = never>(register: (callback: (_: Effect<A, E, R>) => void, signal: AbortSignal) => void | Effect<void, never, R>, blockingOn?: FiberId.FiberId) => Effect<A, E, R>;
 /**
  * Converts an asynchronous, callback-style API into an `Effect`, which will
  * be executed asynchronously.
@@ -768,13 +767,13 @@ export declare const async: <R, E, A>(register: (callback: (_: Effect<R, E, A>)
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncEffect: <R, E, A, R2, E2, X>(register: (callback: (_: Effect<R, E, A>) => void) => Effect<R2, E2, X>) => Effect<R | R2, E | E2, A>;
+export declare const asyncEffect: <A, E, R, X, E2, R2>(register: (callback: (_: Effect<A, E, R>) => void) => Effect<X, E2, R2>) => Effect<A, E | E2, R | R2>;
 /**
  * Imports an asynchronous effect into a pure `Effect` value, possibly returning
  * the value synchronously.
  *
  * If the register function returns a value synchronously, then the callback
- * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function `Effect<A, E, R> => void` must not be called. Otherwise the callback
  * function must be called at most once.
  *
  * The `FiberId` of the fiber that may complete the async callback may be
@@ -783,7 +782,7 @@ export declare const asyncEffect: <R, E, A, R2, E2, X>(register: (callback: (_:
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncOption: <R, E, A>(register: (callback: (_: Effect<R, E, A>) => void) => Option.Option<Effect<R, E, A>>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+export declare const asyncOption: <A, E = never, R = never>(register: (callback: (_: Effect<A, E, R>) => void) => Option.Option<Effect<A, E, R>>, blockingOn?: FiberId.FiberId) => Effect<A, E, R>;
 /**
  * Imports an asynchronous side-effect into an effect. It has the option of
  * returning the value synchronously, which is useful in cases where it cannot
@@ -793,7 +792,7 @@ export declare const asyncOption: <R, E, A>(register: (callback: (_: Effect<R, E
  * executing the effect is interrupted.
  *
  * If the register function returns a value synchronously, then the callback
- * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function `Effect<A, E, R> => void` must not be called. Otherwise the callback
  * function must be called at most once.
  *
  * The `FiberId` of the fiber that may complete the async callback may be
@@ -802,32 +801,32 @@ export declare const asyncOption: <R, E, A>(register: (callback: (_: Effect<R, E
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncEither: <R, E, A>(register: (callback: (effect: Effect<R, E, A>) => void) => Either.Either<Effect<R, never, void>, Effect<R, E, A>>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+export declare const asyncEither: <A, E = never, R = never>(register: (callback: (effect: Effect<A, E, R>) => void) => Either.Either<Effect<void, never, R>, Effect<A, E, R>>, blockingOn?: FiberId.FiberId) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(error: E) => Effect<never, E, never>;
+export declare const fail: <E>(error: E) => Effect<never, E>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => Effect<never, E, never>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Effect<never, E>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E, never>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Effect<never, E, never>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Effect<never, E>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const die: (defect: unknown) => Effect<never, never, never>;
+export declare const die: (defect: unknown) => Effect<never>;
 /**
  * Returns an effect that dies with a `RuntimeException` having the specified
  * text message. This method can be used for terminating a fiber because a
@@ -836,65 +835,65 @@ export declare const die: (defect: unknown) => Effect<never, never, never>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieMessage: (message: string) => Effect<never, never, never>;
+export declare const dieMessage: (message: string) => Effect<never>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieSync: (evaluate: LazyArg<unknown>) => Effect<never, never, never>;
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Effect<never>;
 /**
  * @since 2.0.0
  * @category constructors
  */
 export declare const gen: {
-    <Eff extends EffectGen<any, any, any>, AEff>(f: (resume: Adapter) => Generator<Eff, AEff, any>): Effect<[
+    <Eff extends EffectGen<any, any, any>, AEff>(f: (resume: Adapter) => Generator<Eff, AEff, any>): Effect<AEff, [
         Eff
-    ] extends [never] ? never : [Eff] extends [EffectGen<infer R, any, any>] ? R : never, [
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, [
         Eff
-    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, AEff>;
-    <Self, Eff extends EffectGen<any, any, any>, AEff>(self: Self, f: (this: Self, resume: Adapter) => Generator<Eff, AEff, any>): Effect<[
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, any, infer R>] ? R : never>;
+    <Self, Eff extends EffectGen<any, any, any>, AEff>(self: Self, f: (this: Self, resume: Adapter) => Generator<Eff, AEff, any>): Effect<AEff, [
         Eff
-    ] extends [never] ? never : [Eff] extends [EffectGen<infer R, any, any>] ? R : never, [
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, [
         Eff
-    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, AEff>;
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, any, infer R>] ? R : never>;
 };
 /**
  * @category models
  * @since 2.0.0
  */
-export interface EffectGen<out R, out E, out A> {
-    readonly _R: () => R;
-    readonly _E: () => E;
+export interface EffectGen<out A, out E, out R> {
     readonly _A: () => A;
-    readonly value: Effect<R, E, A>;
-    [Symbol.iterator](): Generator<EffectGen<R, E, A>, A>;
+    readonly _E: () => E;
+    readonly _R: () => R;
+    readonly value: Effect<A, E, R>;
+    [Symbol.iterator](): Generator<EffectGen<A, E, R>, A>;
 }
 /**
  * @since 2.0.0
  * @category models
  */
 export interface Adapter {
-    <R, E, A>(self: Effect<R, E, A>): EffectGen<R, E, A>;
-    <A, _R, _E, _A>(a: A, ab: (a: A) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
-    <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
-    <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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: G) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_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) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, E, R>(self: Effect<A, E, R>): EffectGen<A, E, R>;
+    <A, _A, _E, _R>(a: A, ab: (a: A) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, _A, _E, _R>(a: A, ab: (a: A) => B, bc: (b: B) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, _A, _E, _R>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, _A, _E, _R>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, _A, _E, _R>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _A, _E, _R>(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) => Effect<_A, _E, _R>): EffectGen<_A, _E, _R>;
 }
 /**
  * Returns a effect that will never produce anything. The moral equivalent of
@@ -903,14 +902,14 @@ export interface Adapter {
  * @since 2.0.0
  * @category constructors
  */
-export declare const never: Effect<never, never, never>;
+export declare const never: Effect<never>;
 /**
  * Requires the option produced by this value to be `None`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const none: <R, E, A>(self: Effect<R, E, Option.Option<A>>) => Effect<R, E | Cause.NoSuchElementException, void>;
+export declare const none: <A, E, R>(self: Effect<Option.Option<A>, E, R>) => Effect<void, E | Cause.NoSuchElementException, R>;
 /**
  * Like `tryPromise` but produces a defect in case of errors.
  *
@@ -920,65 +919,65 @@ export declare const none: <R, E, A>(self: Effect<R, E, Option.Option<A>>) => Ef
  * @since 2.0.0
  * @category constructors
  */
-export declare const promise: <A>(evaluate: (signal: AbortSignal) => Promise<A>) => Effect<never, never, A>;
+export declare const promise: <A>(evaluate: (signal: AbortSignal) => Promise<A>) => Effect<A>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <A>(value: A) => Effect<never, never, A>;
+export declare const succeed: <A>(value: A) => Effect<A>;
 /**
  * Returns an effect which succeeds with `None`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeedNone: Effect<never, never, Option.Option<never>>;
+export declare const succeedNone: Effect<Option.Option<never>>;
 /**
  * Returns an effect which succeeds with the value wrapped in a `Some`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeedSome: <A>(value: A) => Effect<never, never, Option.Option<A>>;
+export declare const succeedSome: <A>(value: A) => Effect<Option.Option<A>>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const suspend: <R, E, A>(effect: LazyArg<Effect<R, E, A>>) => Effect<R, E, A>;
+export declare const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const sync: <A>(evaluate: LazyArg<A>) => Effect<never, never, A>;
+export declare const sync: <A>(evaluate: LazyArg<A>) => Effect<A>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const unit: Effect<never, never, void>;
+export declare const unit: Effect<void>;
 /**
  * @since 2.0.0
  * @category constructors
  */
 export declare const yieldNow: (options?: {
     readonly priority?: number | undefined;
-}) => Effect<never, never, void>;
+}) => Effect<void>;
 declare const _catch: {
-    <N extends keyof E, K extends E[N] & string, E, R1, E1, A1>(discriminator: N, options: {
+    <N extends keyof E, K extends E[N] & string, E, A1, E1, R1>(discriminator: N, options: {
         readonly failure: K;
         readonly onFailure: (error: Extract<E, {
             [n in N]: K;
-        }>) => Effect<R1, E1, A1>;
-    }): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | Exclude<E, {
+        }>) => Effect<A1, E1, R1>;
+    }): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, {
         [n in N]: K;
-    }>, A1 | A>;
-    <R, E, A, N extends keyof E, K extends E[N] & string, R1, E1, A1>(self: Effect<R, E, A>, discriminator: N, options: {
+    }>, R1 | R>;
+    <A, E, R, N extends keyof E, K extends E[N] & string, A1, E1, R1>(self: Effect<A, E, R>, discriminator: N, options: {
         readonly failure: K;
         readonly onFailure: (error: Extract<E, {
             [n in N]: K;
-        }>) => Effect<R1, E1, A1>;
-    }): Effect<R | R1, E1 | Exclude<E, {
+        }>) => Effect<A1, E1, R1>;
+    }): Effect<A | A1, E1 | Exclude<E, {
         [n in N]: K;
-    }>, A | A1>;
+    }>, R | R1>;
 };
 export { 
 /**
@@ -999,8 +998,8 @@ _catch as catch };
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R2, E2, A2>(f: (e: E) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, f: (e: E) => Effect<R2, E2, A2>): Effect<R | R2, E2, A | A2>;
+    <E, A2, E2, R2>(f: (e: E) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (e: E) => Effect<A2, E2, R2>): Effect<A2 | A, E2, R2 | R>;
 };
 /**
  * Recovers from both recoverable and unrecoverable errors.
@@ -1012,8 +1011,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchAllCause: {
-    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>): Effect<R | R2, E2, A | A2>;
+    <E, A2, E2, R2>(f: (cause: Cause.Cause<E>) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Effect<A2, E2, R2>): Effect<A | A2, E2, R | R2>;
 };
 /**
  * Recovers from all defects with provided function.
@@ -1027,8 +1026,8 @@ export declare const catchAllCause: {
  * @category error handling
  */
 export declare const catchAllDefect: {
-    <R2, E2, A2>(f: (defect: unknown) => Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, f: (defect: unknown) => Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+    <A2, E2, R2>(f: (defect: unknown) => Effect<A2, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (defect: unknown) => Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from errors that match the given predicate.
@@ -1037,10 +1036,10 @@ export declare const catchAllDefect: {
  * @category error handling
  */
 export declare const catchIf: {
-    <E, EB extends E, R2, E2, A2>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | Exclude<E, EB>, A2 | A>;
-    <E, R2, E2, A2>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
-    <R, E, A, EA extends E, EB extends EA, R2, E2, A2>(self: Effect<R, E, A>, refinement: Refinement<EA, EB>, f: (e: EB) => Effect<R2, E2, A2>): Effect<R | R2, E2 | Exclude<E, EB>, A | A2>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, predicate: Predicate<E>, f: (e: E) => Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+    <E, EB extends E, A2, E2, R2>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2 | Exclude<E, EB>, R2 | R>;
+    <E, A2, E2, R2>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R2 | R>;
+    <A, E, R, EB extends E, A2, E2, R2>(self: Effect<A, E, R>, refinement: Refinement<E, EB>, f: (e: EB) => Effect<A2, E2, R2>): Effect<A | A2, E2 | Exclude<E, EB>, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, predicate: Predicate<E>, f: (e: E) => Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from some or all of the error cases.
@@ -1049,8 +1048,8 @@ export declare const catchIf: {
  * @category error handling
  */
 export declare const catchSome: {
-    <E, R2, E2, A2>(pf: (e: E) => Option.Option<Effect<R2, E2, A2>>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, pf: (e: E) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+    <E, A2, E2, R2>(pf: (e: NoInfer<E>) => Option.Option<Effect<A2, E2, R2>>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, pf: (e: NoInfer<E>) => Option.Option<Effect<A2, E2, R2>>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from some or all of the error cases with provided cause.
@@ -1059,8 +1058,8 @@ export declare const catchSome: {
  * @category error handling
  */
 export declare const catchSomeCause: {
-    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Option.Option<Effect<R2, E2, A2>>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+    <E, A2, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect<A2, E2, R2>>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect<A2, E2, R2>>): Effect<A2 | A, E | E2, R2 | R>;
 };
 /**
  * Recovers from some or all of the defects with provided partial function.
@@ -1074,8 +1073,8 @@ export declare const catchSomeCause: {
  * @category error handling
  */
 export declare const catchSomeDefect: {
-    <R2, E2, A2>(pf: (defect: unknown) => Option.Option<Effect<R2, E2, A2>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, pf: (defect: unknown) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+    <A2, E2, R2>(pf: (defect: unknown) => Option.Option<Effect<A2, E2, R2>>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, pf: (defect: unknown) => Option.Option<Effect<A2, E2, R2>>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Recovers from the specified tagged error.
@@ -1084,20 +1083,20 @@ export declare const catchSomeDefect: {
  * @category error handling
  */
 export declare const catchTag: {
-    <K extends (E extends {
+    <K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never), E, R1, E1, A1>(k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Effect<R1, E1, A1>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | Exclude<E, {
+    }>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, {
         _tag: K;
-    }>, A1 | A>;
-    <R, E, A, K extends (E extends {
+    }>, R1 | R>;
+    <A, E, R, K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never), R1, E1, A1>(self: Effect<R, E, A>, k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, R1, E1, A1>(self: Effect<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Effect<R1, E1, A1>): Effect<R | R1, E1 | Exclude<E, {
+    }>) => Effect<A1, E1, R1>): Effect<A | A1, E1 | Exclude<E, {
         _tag: K;
-    }>, A | A1>;
+    }>, R | R1>;
 };
 /**
  * Recovers from the specified tagged errors.
@@ -1116,14 +1115,14 @@ export declare const catchTags: {
         [K in Exclude<keyof Cases, Extract<E, {
             _tag: string;
         }>["_tag"]>]: never;
-    })>(cases: Cases): <R, A>(self: Effect<R, E, A>) => Effect<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer R, any, any> ? R : never;
+    })>(cases: Cases): <A, R>(self: Effect<A, E, R>) => Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
     }> | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer A> ? A : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never;
     }[keyof Cases]>;
     <R, E, A, Cases extends {
         [K in Extract<E, {
@@ -1135,14 +1134,14 @@ export declare const catchTags: {
         [K in Exclude<keyof Cases, Extract<E, {
             _tag: string;
         }>["_tag"]>]: never;
-    })>(self: Effect<R, E, A>, cases: Cases): Effect<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer R, any, any> ? R : never;
+    })>(self: Effect<A, E, R>, cases: Cases): Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
     }> | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer A> ? A : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never;
     }[keyof Cases]>;
 };
 /**
@@ -1152,7 +1151,7 @@ export declare const catchTags: {
  * @since 2.0.0
  * @category error handling
  */
-export declare const cause: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Cause.Cause<E>>;
+export declare const cause: <A, E, R>(self: Effect<A, E, R>) => Effect<Cause.Cause<E>, never, R>;
 /**
  * Returns an effect that ignores errors and runs repeatedly until it
  * eventually succeeds.
@@ -1160,14 +1159,14 @@ export declare const cause: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never,
  * @since 2.0.0
  * @category error handling
  */
-export declare const eventually: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
+export declare const eventually: <A, E, R>(self: Effect<A, E, R>) => Effect<A, never, R>;
 /**
  * Returns a new effect that ignores the success or failure of this effect.
  *
  * @since 2.0.0
  * @category error handling
  */
-export declare const ignore: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, void>;
+export declare const ignore: <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R>;
 /**
  * Returns a new effect that ignores the success or failure of this effect,
  * but which also logs failures at the Debug level, just in case the failure
@@ -1176,21 +1175,21 @@ export declare const ignore: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never
  * @since 2.0.0
  * @category error handling
  */
-export declare const ignoreLogged: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, void>;
+export declare const ignoreLogged: <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R>;
 /**
  * Exposes all parallel errors in a single call.
  *
  * @since 2.0.0
  * @category error handling
  */
-export declare const parallelErrors: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Array<E>, A>;
+export declare const parallelErrors: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Array<E>, R>;
 /**
  * Exposes the full `Cause` of failure for the specified effect.
  *
  * @since 2.0.0
  * @category error handling
  */
-export declare const sandbox: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Cause.Cause<E>, A>;
+export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Cause.Cause<E>, R>;
 /**
  * @since 2.0.0
  * @category error handling
@@ -1200,30 +1199,30 @@ export declare namespace Retry {
      * @since 2.0.0
      * @category error handling
      */
-    type Return<R, E, A, O extends Options<E>> = Effect<R | (O extends {
-        schedule: Schedule.Schedule<infer X, infer _I, infer _O>;
-    } ? X : never) | (O extends {
-        while: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
-    } ? X : never) | (O extends {
-        until: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
-    } ? X : never), (O extends {
+    type Return<R, E, A, O extends Options<E>> = Effect<A, (O extends {
         schedule: Schedule.Schedule<infer _R, infer _I, infer _O>;
     } ? E : O extends {
         until: Refinement<E, infer E2>;
     } ? E2 : E) | (O extends {
-        while: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
-    } ? X : never) | (O extends {
-        until: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
-    } ? X : never), A> extends infer Z ? Z : never;
+        while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
+    } ? E : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
+    } ? E : never), R | (O extends {
+        schedule: Schedule.Schedule<infer R, infer _I, infer _O>;
+    } ? R : never) | (O extends {
+        while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R>;
+    } ? R : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R>;
+    } ? R : never)> extends infer Z ? Z : never;
     /**
      * @since 2.0.0
      * @category error handling
      */
     interface Options<E> {
-        while?: (error: E) => boolean | Effect<any, any, boolean>;
-        until?: (error: E) => boolean | Effect<any, any, boolean>;
-        times?: number;
-        schedule?: Schedule.Schedule<any, E, any>;
+        while?: ((error: E) => boolean | Effect<boolean, any, any>) | undefined;
+        until?: ((error: E) => boolean | Effect<boolean, any, any>) | undefined;
+        times?: number | undefined;
+        schedule?: Schedule.Schedule<any, E, any> | undefined;
     }
 }
 /**
@@ -1233,10 +1232,10 @@ export declare namespace Retry {
  * @category error handling
  */
 export declare const retry: {
-    <E, O extends Retry.Options<E>>(options: O): <R, A>(self: Effect<R, E, A>) => Retry.Return<R, E, A, O>;
-    <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
-    <R, A, E, O extends Retry.Options<E>>(self: Effect<R, E, A>, options: O): Retry.Return<R, E, A, O>;
-    <R, E extends E0, E0, A, R1, B>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Effect<R | R1, E, A>;
+    <E, O extends Retry.Options<E>>(options: O): <A, R>(self: Effect<A, E, R>) => Retry.Return<R, E, A, O>;
+    <R1, E, B>(policy: Schedule.Schedule<R1, NoInfer<E>, B>): <A, R>(self: Effect<A, E, R>) => Effect<A, E, R1 | R>;
+    <A, E, R, O extends Retry.Options<E>>(self: Effect<A, E, R>, options: O): Retry.Return<R, E, A, O>;
+    <R, E, A, R1, B>(self: Effect<A, E, R>, policy: Schedule.Schedule<R1, E, B>): Effect<A, E, R1 | R>;
 };
 /**
  * Retries with the specified schedule, until it fails, and then both the
@@ -1247,15 +1246,15 @@ export declare const retry: {
  * @category error handling
  */
 export declare const retryOrElse: {
-    <R1, E extends E3, A1, R2, E2, A2, E3>(policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R2 | R, E | E2, A2 | A>;
-    <R, E extends E3, A, R1, A1, R2, E2, A2, E3>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): Effect<R | R1 | R2, E | E2, A | A2>;
+    <R1, E, A1, A2, E2, R2>(policy: Schedule.Schedule<R1, NoInfer<E>, A1>, orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R1 | R2 | R>;
+    <A, E, R, A1, R1, A2, E2, R2>(self: Effect<A, E, R>, policy: Schedule.Schedule<R1, NoInfer<E>, A1>, orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R1 | R2>;
 };
 declare const try_: {
     <A, E>(options: {
         readonly try: LazyArg<A>;
         readonly catch: (error: unknown) => E;
-    }): Effect<never, E, A>;
-    <A>(evaluate: LazyArg<A>): Effect<never, Cause.UnknownException, A>;
+    }): Effect<A, E>;
+    <A>(evaluate: LazyArg<A>): Effect<A, Cause.UnknownException>;
 };
 export { 
 /**
@@ -1278,11 +1277,11 @@ export declare const tryMap: {
     <A, B, E1>(options: {
         readonly try: (a: A) => B;
         readonly catch: (error: unknown) => E1;
-    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E1 | E, B>;
-    <R, E, A, B, E1>(self: Effect<R, E, A>, options: {
+    }): <E, R>(self: Effect<A, E, R>) => Effect<B, E1 | E, R>;
+    <A, E, R, B, E1>(self: Effect<A, E, R>, options: {
         readonly try: (a: A) => B;
         readonly catch: (error: unknown) => E1;
-    }): Effect<R, E | E1, B>;
+    }): Effect<B, E | E1, R>;
 };
 /**
  * Returns an effect whose success is mapped by the specified side effecting
@@ -1299,11 +1298,11 @@ export declare const tryMapPromise: {
     <A, B, E1>(options: {
         readonly try: (a: A, signal: AbortSignal) => Promise<B>;
         readonly catch: (error: unknown) => E1;
-    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E1 | E, B>;
-    <R, E, A, B, E1>(self: Effect<R, E, A>, options: {
+    }): <E, R>(self: Effect<A, E, R>) => Effect<B, E1 | E, R>;
+    <A, E, R, B, E1>(self: Effect<A, E, R>, options: {
         readonly try: (a: A, signal: AbortSignal) => Promise<B>;
         readonly catch: (error: unknown) => E1;
-    }): Effect<R, E | E1, B>;
+    }): Effect<B, E | E1, R>;
 };
 /**
  * Create an `Effect` that when executed will construct `promise` and wait for
@@ -1319,19 +1318,19 @@ export declare const tryPromise: {
     <A, E>(options: {
         readonly try: (signal: AbortSignal) => Promise<A>;
         readonly catch: (error: unknown) => E;
-    }): Effect<never, E, A>;
-    <A>(try_: (signal: AbortSignal) => Promise<A>): Effect<never, Cause.UnknownException, A>;
+    }): Effect<A, E>;
+    <A>(try_: (signal: AbortSignal) => Promise<A>): Effect<A, Cause.UnknownException>;
 };
 /**
  * The inverse operation `sandbox(effect)`
  *
  * Terminates with exceptions on the `Left` side of the `Either` error, if it
- * exists. Otherwise extracts the contained `Effect<R, E, A>`
+ * exists. Otherwise extracts the contained `Effect<A, E, R>`
  *
  * @since 2.0.0
  * @category error handling
  */
-export declare const unsandbox: <R, E, A>(self: Effect<R, Cause.Cause<E>, A>) => Effect<R, E, A>;
+export declare const unsandbox: <A, E, R>(self: Effect<A, Cause.Cause<E>, R>) => Effect<A, E, R>;
 /**
  * This function checks if any fibers are attempting to interrupt the current
  * fiber, and if so, performs self-interruption.
@@ -1344,7 +1343,7 @@ export declare const unsandbox: <R, E, A>(self: Effect<R, Cause.Cause<E>, A>) =>
  * @since 2.0.0
  * @category interruption
  */
-export declare const allowInterrupt: Effect<never, never, void>;
+export declare const allowInterrupt: Effect<void>;
 /**
  * Checks the interrupt status, and produces the effect returned by the
  * specified callback.
@@ -1352,7 +1351,7 @@ export declare const allowInterrupt: Effect<never, never, void>;
  * @since 2.0.0
  * @category interruption
  */
-export declare const checkInterruptible: <R, E, A>(f: (isInterruptible: boolean) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const checkInterruptible: <A, E, R>(f: (isInterruptible: boolean) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns an effect whose interruption will be disconnected from the
  * fiber's own interruption, being performed in the background without
@@ -1369,45 +1368,45 @@ export declare const checkInterruptible: <R, E, A>(f: (isInterruptible: boolean)
  * @since 2.0.0
  * @category interruption
  */
-export declare const disconnect: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const disconnect: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const interrupt: Effect<never, never, never>;
+export declare const interrupt: Effect<never>;
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const interruptWith: (fiberId: FiberId.FiberId) => Effect<never, never, never>;
+export declare const interruptWith: (fiberId: FiberId.FiberId) => Effect<never>;
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const interruptible: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const interruptible: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const interruptibleMask: <R, E, A>(f: (restore: <RX, EX, AX>(effect: Effect<RX, EX, AX>) => Effect<RX, EX, AX>) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const interruptibleMask: <A, E, R>(f: (restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category interruption
  */
 export declare const onInterrupt: {
-    <R2, X>(cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<R2, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
-    <R, E, A, R2, X>(self: Effect<R, E, A>, cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+    <X, R2>(cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<X, never, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Effect<A, E, R>, cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<X, never, R2>): Effect<A, E, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const uninterruptible: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const uninterruptible: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category interruption
  */
-export declare const uninterruptibleMask: <R, E, A>(f: (restore: <RX, EX, AX>(effect: Effect<RX, EX, AX>) => Effect<RX, EX, AX>) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const uninterruptibleMask: <A, E, R>(f: (restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * This function maps the success value of an `Effect` value to a specified
  * constant value.
@@ -1424,8 +1423,8 @@ export declare const uninterruptibleMask: <R, E, A>(f: (restore: <RX, EX, AX>(ef
  * @category mapping
  */
 export declare const as: {
-    <B>(value: B): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, B>;
-    <R, E, A, B>(self: Effect<R, E, A>, value: B): Effect<R, E, B>;
+    <B>(value: B): <A, E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
+    <A, E, R, B>(self: Effect<A, E, R>, value: B): Effect<B, E, R>;
 };
 /**
  * This function maps the success value of an `Effect` value to a `Some` value
@@ -1443,7 +1442,7 @@ export declare const as: {
  * @category mapping
  * @since 2.0.0
  */
-export declare const asSome: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
+export declare const asSome: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E, R>;
 /**
  * This function maps the error value of an `Effect` value to a `Some` value
  * in an `Option` value. If the original `Effect` value succeeds, the returned
@@ -1460,7 +1459,7 @@ export declare const asSome: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Op
  * @category mapping
  * @since 2.0.0
  */
-export declare const asSomeError: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Option.Option<E>, A>;
+export declare const asSomeError: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Option.Option<E>, R>;
 /**
  * This function maps the success value of an `Effect` value to `void`. If the
  * original `Effect` value succeeds, the returned `Effect` value will also
@@ -1475,7 +1474,7 @@ export declare const asSomeError: <R, E, A>(self: Effect<R, E, A>) => Effect<R,
  * @since 2.0.0
  * @category mapping
  */
-export declare const asUnit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, void>;
+export declare const asUnit: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R>;
 /**
  * Returns an effect that swaps the error/success cases. This allows you to
  * use all methods on the error channel, possibly before flipping back.
@@ -1483,7 +1482,7 @@ export declare const asUnit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, vo
  * @since 2.0.0
  * @category mapping
  */
-export declare const flip: <R, E, A>(self: Effect<R, E, A>) => Effect<R, A, E>;
+export declare const flip: <A, E, R>(self: Effect<A, E, R>) => Effect<E, A, R>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the
  * parameters back
@@ -1492,16 +1491,16 @@ export declare const flip: <R, E, A>(self: Effect<R, E, A>) => Effect<R, A, E>;
  * @category mapping
  */
 export declare const flipWith: {
-    <R, A, E, R2, A2, E2>(f: (effect: Effect<R, A, E>) => Effect<R2, A2, E2>): (self: Effect<R, E, A>) => Effect<R2, E2, A2>;
-    <R, A, E, R2, A2, E2>(self: Effect<R, E, A>, f: (effect: Effect<R, A, E>) => Effect<R2, A2, E2>): Effect<R2, E2, A2>;
+    <E, A, R, E2, A2, R2>(f: (effect: Effect<E, A, R>) => Effect<E2, A2, R2>): (self: Effect<A, E, R>) => Effect<A2, E2, R2>;
+    <A, E, R, E2, A2, R2>(self: Effect<A, E, R>, f: (effect: Effect<E, A, R>) => Effect<E2, A2, R2>): Effect<A2, E2, R2>;
 };
 /**
  * @since 2.0.0
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
-    <R, E, A, B>(self: Effect<R, E, A>, f: (a: A) => B): Effect<R, E, B>;
+    <A, B>(f: (a: A) => B): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
+    <A, E, R, B>(self: Effect<A, E, R>, f: (a: A) => B): Effect<B, E, R>;
 };
 /**
  * Statefully and effectfully maps over the elements of this chunk to produce
@@ -1511,8 +1510,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapAccum: {
-    <A, B, R, E, Z>(zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, readonly [Z, B]>): (elements: Iterable<A>) => Effect<R, E, [Z, Array<B>]>;
-    <A, B, R, E, Z>(elements: Iterable<A>, zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, readonly [Z, B]>): Effect<R, E, [Z, Array<B>]>;
+    <S, A, B, E, R>(zero: S, f: (s: S, a: A, i: number) => Effect<readonly [S, B], E, R>): (elements: Iterable<A>) => Effect<[S, Array<B>], E, R>;
+    <A, S, B, E, R>(elements: Iterable<A>, zero: S, f: (s: S, a: A, i: number) => Effect<readonly [S, B], E, R>): Effect<[S, Array<B>], E, R>;
 };
 /**
  * Returns an effect whose failure and success channels have been mapped by
@@ -1522,14 +1521,14 @@ export declare const mapAccum: {
  * @category mapping
  */
 export declare const mapBoth: {
-    <E, A, E2, A2>(options: {
+    <E, E2, A, A2>(options: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
-    }): <R>(self: Effect<R, E, A>) => Effect<R, E2, A2>;
-    <R, E, A, E2, A2>(self: Effect<R, E, A>, options: {
+    }): <R>(self: Effect<A, E, R>) => Effect<A2, E2, R>;
+    <A, E, R, E2, A2>(self: Effect<A, E, R>, options: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
-    }): Effect<R, E2, A2>;
+    }): Effect<A2, E2, R>;
 };
 /**
  * Returns an effect with its error channel mapped using the specified function.
@@ -1538,8 +1537,8 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (e: E) => E2): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
-    <R, A, E, E2>(self: Effect<R, E, A>, f: (e: E) => E2): Effect<R, E2, A>;
+    <E, E2>(f: (e: E) => E2): <A, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
+    <A, E, R, E2>(self: Effect<A, E, R>, f: (e: E) => E2): Effect<A, E2, R>;
 };
 /**
  * Returns an effect with its full cause of failure mapped using the specified
@@ -1553,8 +1552,8 @@ export declare const mapError: {
  * @category mapping
  */
 export declare const mapErrorCause: {
-    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
-    <R, E, A, E2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Effect<R, E2, A>;
+    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
+    <A, E, R, E2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Effect<A, E2, R>;
 };
 /**
  * Returns a new effect where the error channel has been merged into the
@@ -1563,14 +1562,14 @@ export declare const mapErrorCause: {
  * @since 2.0.0
  * @category mapping
  */
-export declare const merge: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, E | A>;
+export declare const merge: <A, E, R>(self: Effect<A, E, R>) => Effect<E | A, never, R>;
 /**
  * Returns a new effect where boolean value of this effect is negated.
  *
  * @since 2.0.0
  * @category mapping
  */
-export declare const negate: <R, E>(self: Effect<R, E, boolean>) => Effect<R, E, boolean>;
+export declare const negate: <R, E>(self: Effect<boolean, E, R>) => Effect<boolean, E, R>;
 /**
  * This function constructs a scoped resource from an `acquire` and `release`
  * `Effect` value.
@@ -1593,8 +1592,8 @@ export declare const negate: <R, E>(self: Effect<R, E, boolean>) => Effect<R, E,
  * @category scoping, resources & finalization
  */
 export declare const acquireRelease: {
-    <A, R2, X>(release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, E, A>;
-    <R, E, A, R2, X>(acquire: Effect<R, E, A>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): Effect<Scope.Scope | R | R2, E, A>;
+    <A, X, R2>(release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R2>): <E, R>(acquire: Effect<A, E, R>) => Effect<A, E, Scope.Scope | R2 | R>;
+    <A, E, R, X, R2>(acquire: Effect<A, E, R>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R2>): Effect<A, E, Scope.Scope | R | R2>;
 };
 /**
  * This function constructs a scoped resource from an `acquire` and `release`
@@ -1620,8 +1619,8 @@ export declare const acquireRelease: {
  * @category scoping, resources & finalization
  */
 export declare const acquireReleaseInterruptible: {
-    <A, R2, X>(release: (exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, E, A>;
-    <R, E, A, R2, X>(acquire: Effect<R, E, A>, release: (exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): Effect<Scope.Scope | R | R2, E, A>;
+    <X, R2>(release: (exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R2>): <A, E, R>(acquire: Effect<A, E, R>) => Effect<A, E, Scope.Scope | R2 | R>;
+    <A, E, R, X, R2>(acquire: Effect<A, E, R>, release: (exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R2>): Effect<A, E, Scope.Scope | R | R2>;
 };
 /**
  * This function is used to ensure that an `Effect` value that represents the
@@ -1658,8 +1657,8 @@ export declare const acquireReleaseInterruptible: {
  * @category scoping, resources & finalization
  */
 export declare const acquireUseRelease: {
-    <A, R2, E2, A2, R3, X>(use: (a: A) => Effect<R2, E2, A2>, release: (a: A, exit: Exit.Exit<E2, A2>) => Effect<R3, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2, R3, X>(acquire: Effect<R, E, A>, use: (a: A) => Effect<R2, E2, A2>, release: (a: A, exit: Exit.Exit<E2, A2>) => Effect<R3, never, X>): Effect<R | R2 | R3, E | E2, A2>;
+    <A2, E2, R2, A, X, R3>(use: (a: A) => Effect<A2, E2, R2>, release: (a: A, exit: Exit.Exit<A2, E2>) => Effect<X, never, R3>): <E, R>(acquire: Effect<A, E, R>) => Effect<A2, E2 | E, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, X, R3>(acquire: Effect<A, E, R>, use: (a: A) => Effect<A2, E2, R2>, release: (a: A, exit: Exit.Exit<A2, E2>) => Effect<X, never, R3>): Effect<A2, E | E2, R | R2 | R3>;
 };
 /**
  * This function adds a finalizer to the scope of the calling `Effect` value.
@@ -1676,7 +1675,7 @@ export declare const acquireUseRelease: {
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const addFinalizer: <R, X>(finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<R, never, X>) => Effect<R | Scope.Scope, never, void>;
+export declare const addFinalizer: <X, R>(finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<X, never, R>) => Effect<void, never, Scope.Scope | R>;
 /**
  * Returns an effect that, if this effect _starts_ execution, then the
  * specified `finalizer` is guaranteed to be executed, whether this effect
@@ -1692,8 +1691,8 @@ export declare const addFinalizer: <R, X>(finalizer: (exit: Exit.Exit<unknown, u
  * @category scoping, resources & finalization
  */
 export declare const ensuring: {
-    <R1, X>(finalizer: Effect<R1, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
-    <R, E, A, R1, X>(self: Effect<R, E, A>, finalizer: Effect<R1, never, X>): Effect<R | R1, E, A>;
+    <X, R1>(finalizer: Effect<X, never, R1>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R1 | R>;
+    <A, E, R, X, R1>(self: Effect<A, E, R>, finalizer: Effect<X, never, R1>): Effect<A, E, R1 | R>;
 };
 /**
  * Runs the specified effect if this effect fails, providing the error to the
@@ -1703,8 +1702,8 @@ export declare const ensuring: {
  * @category scoping, resources & finalization
  */
 export declare const onError: {
-    <E, R2, X>(cleanup: (cause: Cause.Cause<E>) => Effect<R2, never, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
-    <R, A, E, R2, X>(self: Effect<R, E, A>, cleanup: (cause: Cause.Cause<E>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+    <E, X, R2>(cleanup: (cause: Cause.Cause<E>) => Effect<X, never, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Effect<A, E, R>, cleanup: (cause: Cause.Cause<E>) => Effect<X, never, R2>): Effect<A, E, R2 | R>;
 };
 /**
  * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
@@ -1714,19 +1713,19 @@ export declare const onError: {
  * @category scoping, resources & finalization
  */
 export declare const onExit: {
-    <E, A, R2, X>(cleanup: (exit: Exit.Exit<E, A>) => Effect<R2, never, X>): <R>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
-    <R, E, A, R2, X>(self: Effect<R, E, A>, cleanup: (exit: Exit.Exit<E, A>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+    <A, E, X, R2>(cleanup: (exit: Exit.Exit<A, E>) => Effect<X, never, R2>): <R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Effect<A, E, R>, cleanup: (exit: Exit.Exit<A, E>) => Effect<X, never, R2>): Effect<A, E, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const parallelFinalizers: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const parallelFinalizers: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const finalizersMask: (strategy: ExecutionStrategy) => <R, E, A>(self: (restore: <R1, E1, A1>(self: Effect<R1, E1, A1>) => Effect<R1, E1, A1>) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const finalizersMask: (strategy: ExecutionStrategy) => <A, E, R>(self: (restore: <A1, E1, R1>(self: Effect<A1, E1, R1>) => Effect<A1, E1, R1>) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns a new scoped workflow that runs finalizers added to the scope of
  * this workflow sequentially in the reverse of the order in which they were
@@ -1737,7 +1736,7 @@ export declare const finalizersMask: (strategy: ExecutionStrategy) => <R, E, A>(
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const sequentialFinalizers: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const sequentialFinalizers: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category scoping, resources & finalization
@@ -1749,7 +1748,7 @@ export declare const scope: Effect<Scope.Scope, never, Scope.Scope>;
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const scopeWith: <R, E, A>(f: (scope: Scope.Scope) => Effect<R, E, A>) => Effect<R | Scope.Scope, E, A>;
+export declare const scopeWith: <A, E, R>(f: (scope: Scope.Scope) => Effect<A, E, R>) => Effect<A, E, R | Scope.Scope>;
 /**
  * Scopes all resources uses in this workflow to the lifetime of the workflow,
  * ensuring that their finalizers are run as soon as this workflow completes
@@ -1758,7 +1757,7 @@ export declare const scopeWith: <R, E, A>(f: (scope: Scope.Scope) => Effect<R, E
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const scoped: <R, E, A>(effect: Effect<R, E, A>) => Effect<Exclude<R, Scope.Scope>, E, A>;
+export declare const scoped: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Scopes all resources acquired by `resource` to the lifetime of `use`
  * without effecting the scope of any resources acquired by `use`.
@@ -1767,8 +1766,8 @@ export declare const scoped: <R, E, A>(effect: Effect<R, E, A>) => Effect<Exclud
  * @category scoping, resources & finalization
  */
 export declare const using: {
-    <A, R2, E2, A2>(use: (a: A) => Effect<R2, E2, A2>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | Exclude<R, Scope.Scope>, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, use: (a: A) => Effect<R2, E2, A2>): Effect<R2 | Exclude<R, Scope.Scope>, E | E2, A2>;
+    <A, A2, E2, R2>(use: (a: A) => Effect<A2, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<A2, E2 | E, R2 | Exclude<R, Scope.Scope>>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, use: (a: A) => Effect<A2, E2, R2>): Effect<A2, E | E2, R2 | Exclude<R, Scope.Scope>>;
 };
 /**
  * Returns a new scoped workflow that returns the result of this workflow as
@@ -1777,7 +1776,7 @@ export declare const using: {
  * @since 2.0.0
  * @category scoping, resources & finalization
  */
-export declare const withEarlyRelease: <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R, E, [Effect<never, never, void>, A]>;
+export declare const withEarlyRelease: <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<void>, A], E, R | Scope.Scope>;
 /**
  * Returns a new effect that will not succeed with its value before first
  * waiting for the end of all child fibers forked by the effect.
@@ -1785,7 +1784,7 @@ export declare const withEarlyRelease: <R, E, A>(self: Effect<R, E, A>) => Effec
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const awaitAllChildren: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const awaitAllChildren: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns a new workflow that will not supervise any fibers forked by this
  * workflow.
@@ -1793,21 +1792,21 @@ export declare const awaitAllChildren: <R, E, A>(self: Effect<R, E, A>) => Effec
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const daemonChildren: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const daemonChildren: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Constructs an effect with information about the current `Fiber`.
  *
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const descriptor: Effect<never, never, Fiber.Fiber.Descriptor>;
+export declare const descriptor: Effect<Fiber.Fiber.Descriptor>;
 /**
  * Constructs an effect based on information about the current `Fiber`.
  *
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const descriptorWith: <R, E, A>(f: (descriptor: Fiber.Fiber.Descriptor) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const descriptorWith: <A, E, R>(f: (descriptor: Fiber.Fiber.Descriptor) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns a new workflow that executes this one and captures the changes in
  * `FiberRef` values.
@@ -1815,7 +1814,7 @@ export declare const descriptorWith: <R, E, A>(f: (descriptor: Fiber.Fiber.Descr
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const diffFiberRefs: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, [FiberRefsPatch.FiberRefsPatch, A]>;
+export declare const diffFiberRefs: <A, E, R>(self: Effect<A, E, R>) => Effect<[FiberRefsPatch.FiberRefsPatch, A], E, R>;
 /**
  * Acts on the children of this fiber (collected into a single fiber),
  * guaranteeing the specified callback will be invoked, whether or not this
@@ -1825,8 +1824,8 @@ export declare const diffFiberRefs: <R, E, A>(self: Effect<R, E, A>) => Effect<R
  * @category supervision & fibers
  */
 export declare const ensuringChild: {
-    <R2, X>(f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<R2, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
-    <R, E, A, R2, X>(self: Effect<R, E, A>, f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+    <X, R2>(f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect<X, never, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Effect<A, E, R>, f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect<X, never, R2>): Effect<A, E, R | R2>;
 };
 /**
  * Acts on the children of this fiber, guaranteeing the specified callback
@@ -1836,19 +1835,19 @@ export declare const ensuringChild: {
  * @category supervision & fibers
  */
 export declare const ensuringChildren: {
-    <R1, X>(children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<R1, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
-    <R, E, A, R1, X>(self: Effect<R, E, A>, children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<R1, never, X>): Effect<R | R1, E, A>;
+    <X, R2>(children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<X, never, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Effect<A, E, R>, children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<X, never, R2>): Effect<A, E, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const fiberId: Effect<never, never, FiberId.FiberId>;
+export declare const fiberId: Effect<FiberId.FiberId>;
 /**
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const fiberIdWith: <R, E, A>(f: (descriptor: FiberId.Runtime) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const fiberIdWith: <A, E, R>(f: (descriptor: FiberId.Runtime) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns an effect that forks this effect into its own separate fiber,
  * returning the fiber immediately, without waiting for it to begin executing
@@ -1873,7 +1872,7 @@ export declare const fiberIdWith: <R, E, A>(f: (descriptor: FiberId.Runtime) =>
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const fork: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+export declare const fork: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>;
 /**
  * Forks the effect into a new fiber attached to the global scope. Because the
  * new fiber is attached to the global scope, when the fiber executing the
@@ -1882,7 +1881,7 @@ export declare const fork: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never,
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const forkDaemon: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+export declare const forkDaemon: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>;
 /**
  * Returns an effect that forks all of the specified values, and returns a
  * composite fiber that produces a list of their results, in order.
@@ -1893,16 +1892,16 @@ export declare const forkDaemon: <R, E, A>(self: Effect<R, E, A>) => Effect<R, n
 export declare const forkAll: {
     (options?: {
         readonly discard?: false | undefined;
-    }): <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, never, Fiber.Fiber<E, Array<A>>>;
+    }): <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<Fiber.Fiber<Array<A>, E>, never, R>;
     (options: {
         readonly discard: true;
-    }): <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, never, void>;
-    <R, E, A>(effects: Iterable<Effect<R, E, A>>, options?: {
+    }): <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<void, never, R>;
+    <A, E, R>(effects: Iterable<Effect<A, E, R>>, options?: {
         readonly discard?: false | undefined;
-    }): Effect<R, never, Fiber.Fiber<E, Array<A>>>;
-    <R, E, A>(effects: Iterable<Effect<R, E, A>>, options: {
+    }): Effect<Fiber.Fiber<Array<A>, E>, never, R>;
+    <A, E, R>(effects: Iterable<Effect<A, E, R>>, options: {
         readonly discard: true;
-    }): Effect<R, never, void>;
+    }): Effect<void, never, R>;
 };
 /**
  * Forks the effect in the specified scope. The fiber will be interrupted
@@ -1912,8 +1911,8 @@ export declare const forkAll: {
  * @category supervision & fibers
  */
 export declare const forkIn: {
-    (scope: Scope.Scope): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
-    <R, E, A>(self: Effect<R, E, A>, scope: Scope.Scope): Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+    (scope: Scope.Scope): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>;
+    <A, E, R>(self: Effect<A, E, R>, scope: Scope.Scope): Effect<Fiber.RuntimeFiber<A, E>, never, R>;
 };
 /**
  * Forks the fiber in a `Scope`, interrupting it when the scope is closed.
@@ -1921,7 +1920,7 @@ export declare const forkIn: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const forkScoped: <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R, never, Fiber.RuntimeFiber<E, A>>;
+export declare const forkScoped: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, Scope.Scope | R>;
 /**
  * Like fork but handles an error with the provided handler.
  *
@@ -1929,8 +1928,8 @@ export declare const forkScoped: <R, E, A>(self: Effect<R, E, A>) => Effect<Scop
  * @category supervision & fibers
  */
 export declare const forkWithErrorHandler: {
-    <E, X>(handler: (e: E) => Effect<never, never, X>): <R, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
-    <R, E, A, X>(self: Effect<R, E, A>, handler: (e: E) => Effect<never, never, X>): Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+    <E, X>(handler: (e: E) => Effect<X>): <R, A>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>;
+    <R, E, A, X>(self: Effect<A, E, R>, handler: (e: E) => Effect<X>): Effect<Fiber.RuntimeFiber<A, E>, never, R>;
 };
 /**
  * Creates an `Effect` value that represents the exit value of the specified
@@ -1939,7 +1938,7 @@ export declare const forkWithErrorHandler: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const fromFiber: <E, A>(fiber: Fiber.Fiber<E, A>) => Effect<never, E, A>;
+export declare const fromFiber: <A, E>(fiber: Fiber.Fiber<A, E>) => Effect<A, E>;
 /**
  * Creates an `Effect` value that represents the exit value of the specified
  * fiber.
@@ -1947,7 +1946,7 @@ export declare const fromFiber: <E, A>(fiber: Fiber.Fiber<E, A>) => Effect<never
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const fromFiberEffect: <R, E, A>(fiber: Effect<R, E, Fiber.Fiber<E, A>>) => Effect<R, E, A>;
+export declare const fromFiberEffect: <A, E, R>(fiber: Effect<Fiber.Fiber<A, E>, E, R>) => Effect<A, E, R>;
 /**
  * Returns an effect with the behavior of this one, but where all child fibers
  * forked in the effect are reported to the specified supervisor.
@@ -1956,8 +1955,8 @@ export declare const fromFiberEffect: <R, E, A>(fiber: Effect<R, E, Fiber.Fiber<
  * @category supervision & fibers
  */
 export declare const supervised: {
-    <X>(supervisor: Supervisor.Supervisor<X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A, X>(self: Effect<R, E, A>, supervisor: Supervisor.Supervisor<X>): Effect<R, E, A>;
+    <X>(supervisor: Supervisor.Supervisor<X>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <R, E, A, X>(self: Effect<A, E, R>, supervisor: Supervisor.Supervisor<X>): Effect<A, E, R>;
 };
 /**
  * Transplants specified effects so that when those effects fork other
@@ -1970,14 +1969,14 @@ export declare const supervised: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export declare const transplant: <R, E, A>(f: (grafter: <R2, E2, A2>(effect: Effect<R2, E2, A2>) => Effect<R2, E2, A2>) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const transplant: <A, E, R>(f: (grafter: <A2, E2, R2>(effect: Effect<A2, E2, R2>) => Effect<A2, E2, R2>) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category supervision & fibers
  */
 export declare const withConcurrency: {
-    (concurrency: number | "unbounded"): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, concurrency: number | "unbounded"): Effect<R, E, A>;
+    (concurrency: number | "unbounded"): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, concurrency: number | "unbounded"): Effect<A, E, R>;
 };
 /**
  * Sets the provided scheduler for usage in the wrapped effect
@@ -1986,8 +1985,8 @@ export declare const withConcurrency: {
  * @category scheduler
  */
 export declare const withScheduler: {
-    (scheduler: Scheduler.Scheduler): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B>(self: Effect<R, E, B>, scheduler: Scheduler.Scheduler): Effect<R, E, B>;
+    (scheduler: Scheduler.Scheduler): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, scheduler: Scheduler.Scheduler): Effect<A, E, R>;
 };
 /**
  * Sets the scheduling priority used when yielding
@@ -1996,8 +1995,8 @@ export declare const withScheduler: {
  * @category utils
  */
 export declare const withSchedulingPriority: {
-    (priority: number): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B>(self: Effect<R, E, B>, priority: number): Effect<R, E, B>;
+    (priority: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, priority: number): Effect<A, E, R>;
 };
 /**
  * Sets the maximum number of operations before yield by the default schedulers
@@ -2006,8 +2005,8 @@ export declare const withSchedulingPriority: {
  * @category utils
  */
 export declare const withMaxOpsBeforeYield: {
-    (priority: number): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B>(self: Effect<R, E, B>, priority: number): Effect<R, E, B>;
+    (priority: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, priority: number): Effect<A, E, R>;
 };
 /**
  * Retreives the `Clock` service from the context
@@ -2015,7 +2014,7 @@ export declare const withMaxOpsBeforeYield: {
  * @since 2.0.0
  * @category clock
  */
-export declare const clock: Effect<never, never, Clock.Clock>;
+export declare const clock: Effect<Clock.Clock>;
 /**
  * Retreives the `Clock` service from the context and provides it to the
  * specified effectful function.
@@ -2023,7 +2022,7 @@ export declare const clock: Effect<never, never, Clock.Clock>;
  * @since 2.0.0
  * @category clock
  */
-export declare const clockWith: <R, E, A>(f: (clock: Clock.Clock) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const clockWith: <A, E, R>(f: (clock: Clock.Clock) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Sets the implementation of the clock service to the specified value and
  * restores it to its original value when the scope is closed.
@@ -2031,7 +2030,7 @@ export declare const clockWith: <R, E, A>(f: (clock: Clock.Clock) => Effect<R, E
  * @since 2.0.0
  * @category constructors
  */
-export declare const withClockScoped: <A extends Clock.Clock>(value: A) => Effect<Scope.Scope, never, void>;
+export declare const withClockScoped: <A extends Clock.Clock>(value: A) => Effect<void, never, Scope.Scope>;
 /**
  * Executes the specified workflow with the specified implementation of the
  * clock service.
@@ -2040,8 +2039,8 @@ export declare const withClockScoped: <A extends Clock.Clock>(value: A) => Effec
  * @category clock
  */
 export declare const withClock: {
-    <A extends Clock.Clock>(value: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A extends Clock.Clock>(effect: Effect<R, E, A>, value: A): Effect<R, E, A>;
+    <A extends Clock.Clock>(value: A): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <R, E, A extends Clock.Clock>(effect: Effect<A, E, R>, value: A): Effect<A, E, R>;
 };
 /**
  * Retreives the `Console` service from the context
@@ -2049,7 +2048,7 @@ export declare const withClock: {
  * @since 2.0.0
  * @category console
  */
-export declare const console: Effect<never, never, Console>;
+export declare const console: Effect<Console>;
 /**
  * Retreives the `Console` service from the context and provides it to the
  * specified effectful function.
@@ -2057,7 +2056,7 @@ export declare const console: Effect<never, never, Console>;
  * @since 2.0.0
  * @category console
  */
-export declare const consoleWith: <R, E, A>(f: (console: Console) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const consoleWith: <A, E, R>(f: (console: Console) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Sets the implementation of the console service to the specified value and
  * restores it to its original value when the scope is closed.
@@ -2065,7 +2064,7 @@ export declare const consoleWith: <R, E, A>(f: (console: Console) => Effect<R, E
  * @since 2.0.0
  * @category constructors
  */
-export declare const withConsoleScoped: <A extends Console>(console: A) => Effect<Scope.Scope, never, void>;
+export declare const withConsoleScoped: <A extends Console>(console: A) => Effect<void, never, Scope.Scope>;
 /**
  * Executes the specified workflow with the specified implementation of the
  * console service.
@@ -2074,8 +2073,8 @@ export declare const withConsoleScoped: <A extends Console>(console: A) => Effec
  * @category console
  */
 export declare const withConsole: {
-    <A extends Console>(console: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A extends Console>(effect: Effect<R, E, A>, console: A): Effect<R, E, A>;
+    <C extends Console>(console: C): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R, C extends Console>(effect: Effect<A, E, R>, console: C): Effect<A, E, R>;
 };
 /**
  * Returns an effect that is delayed from this effect by the specified
@@ -2085,8 +2084,8 @@ export declare const withConsole: {
  * @category delays & timeouts
  */
 export declare const delay: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, duration: Duration.DurationInput): Effect<R, E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, E, R>;
 };
 /**
  * Returns an effect that suspends for the specified duration. This method is
@@ -2095,14 +2094,14 @@ export declare const delay: {
  * @since 2.0.0
  * @category delays & timeouts
  */
-export declare const sleep: (duration: Duration.DurationInput) => Effect<never, never, void>;
+export declare const sleep: (duration: Duration.DurationInput) => Effect<void>;
 /**
  * Returns a new effect that executes this one and times the execution.
  *
  * @since 2.0.0
  * @category delays & timeouts
  */
-export declare const timed: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, [Duration.Duration, A]>;
+export declare const timed: <A, E, R>(self: Effect<A, E, R>) => Effect<[Duration.Duration, A], E, R>;
 /**
  * A more powerful variation of `timed` that allows specifying the clock.
  *
@@ -2110,8 +2109,8 @@ export declare const timed: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, [Du
  * @category delays & timeouts
  */
 export declare const timedWith: {
-    <R1, E1>(nanoseconds: Effect<R1, E1, bigint>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, [Duration.Duration, A]>;
-    <R, E, A, R1, E1>(self: Effect<R, E, A>, nanoseconds: Effect<R1, E1, bigint>): Effect<R | R1, E | E1, [Duration.Duration, A]>;
+    <E1, R1>(nanoseconds: Effect<bigint, E1, R1>): <A, E, R>(self: Effect<A, E, R>) => Effect<[Duration.Duration, A], E1 | E, R1 | R>;
+    <A, E, R, E1, R1>(self: Effect<A, E, R>, nanoseconds: Effect<bigint, E1, R1>): Effect<[Duration.Duration, A], E | E1, R | R1>;
 };
 /**
  * Returns an effect that will timeout this effect, returning `None` if the
@@ -2133,8 +2132,8 @@ export declare const timedWith: {
  * @category delays & timeouts
  */
 export declare const timeout: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E | Cause.NoSuchElementException, A>;
-    <R, E, A>(self: Effect<R, E, A>, duration: Duration.DurationInput): Effect<R, Cause.NoSuchElementException | E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutException, R>;
+    <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, Cause.TimeoutException | E, R>;
 };
 /**
  * The same as `timeout`, but instead of producing a `None` in the event of
@@ -2147,11 +2146,11 @@ export declare const timeoutFail: {
     <E1>(options: {
         readonly onTimeout: LazyArg<E1>;
         readonly duration: Duration.DurationInput;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E1 | E, A>;
-    <R, E, A, E1>(self: Effect<R, E, A>, options: {
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E1 | E, R>;
+    <A, E, R, E1>(self: Effect<A, E, R>, options: {
         readonly onTimeout: LazyArg<E1>;
         readonly duration: Duration.DurationInput;
-    }): Effect<R, E | E1, A>;
+    }): Effect<A, E | E1, R>;
 };
 /**
  * The same as `timeout`, but instead of producing a `None` in the event of
@@ -2164,11 +2163,11 @@ export declare const timeoutFailCause: {
     <E1>(options: {
         readonly onTimeout: LazyArg<Cause.Cause<E1>>;
         readonly duration: Duration.DurationInput;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E1 | E, A>;
-    <R, E, A, E1>(self: Effect<R, E, A>, options: {
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E1 | E, R>;
+    <A, E, R, E1>(self: Effect<A, E, R>, options: {
         readonly onTimeout: LazyArg<Cause.Cause<E1>>;
         readonly duration: Duration.DurationInput;
-    }): Effect<R, E | E1, A>;
+    }): Effect<A, E | E1, R>;
 };
 /**
  * Returns an effect that will timeout this effect, returning either the
@@ -2187,12 +2186,12 @@ export declare const timeoutTo: {
         readonly onTimeout: LazyArg<B1>;
         readonly onSuccess: (a: A) => B;
         readonly duration: Duration.DurationInput;
-    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B | B1>;
-    <R, E, A, B, B1>(self: Effect<R, E, A>, options: {
+    }): <E, R>(self: Effect<A, E, R>) => Effect<B | B1, E, R>;
+    <A, E, R, B1, B>(self: Effect<A, E, R>, options: {
         readonly onTimeout: LazyArg<B1>;
         readonly onSuccess: (a: A) => B;
         readonly duration: Duration.DurationInput;
-    }): Effect<R, E, B | B1>;
+    }): Effect<B1 | B, E, R>;
 };
 /**
  * Retrieves the default config provider, and passes it to the specified
@@ -2202,7 +2201,7 @@ export declare const timeoutTo: {
  * @since 2.0.0
  * @category config
  */
-export declare const configProviderWith: <R, E, A>(f: (configProvider: ConfigProvider) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const configProviderWith: <A, E, R>(f: (configProvider: ConfigProvider) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Executes the specified workflow with the specified configuration provider.
  *
@@ -2210,8 +2209,8 @@ export declare const configProviderWith: <R, E, A>(f: (configProvider: ConfigPro
  * @category config
  */
 export declare const withConfigProvider: {
-    (value: ConfigProvider): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, value: ConfigProvider): Effect<R, E, A>;
+    (value: ConfigProvider): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, value: ConfigProvider): Effect<A, E, R>;
 };
 /**
  * Sets the configuration provider to the specified value and restores it to its original value
@@ -2220,26 +2219,26 @@ export declare const withConfigProvider: {
  * @since 2.0.0
  * @category config
  */
-export declare const withConfigProviderScoped: (value: ConfigProvider) => Effect<Scope.Scope, never, void>;
+export declare const withConfigProviderScoped: (value: ConfigProvider) => Effect<void, never, Scope.Scope>;
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const context: <R>() => Effect<R, never, Context.Context<R>>;
+export declare const context: <R>() => Effect<Context.Context<R>, never, R>;
 /**
  * Accesses the context of the effect.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWith: <R, A>(f: (context: Context.Context<R>) => A) => Effect<R, never, A>;
+export declare const contextWith: <R, A>(f: (context: Context.Context<R>) => A) => Effect<A, never, R>;
 /**
  * Effectually accesses the context of the effect.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWithEffect: <R, R0, E, A>(f: (context: Context.Context<R0>) => Effect<R, E, A>) => Effect<R | R0, E, A>;
+export declare const contextWithEffect: <R0, A, E, R>(f: (context: Context.Context<R0>) => Effect<A, E, R>) => Effect<A, E, R | R0>;
 /**
  * Provides some of the context required to run this effect,
  * leaving the remainder `R0`.
@@ -2248,8 +2247,8 @@ export declare const contextWithEffect: <R, R0, E, A>(f: (context: Context.Conte
  * @category context
  */
 export declare const mapInputContext: {
-    <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <E, A>(self: Effect<R, E, A>) => Effect<R0, E, A>;
-    <R0, R, E, A>(self: Effect<R, E, A>, f: (context: Context.Context<R0>) => Context.Context<R>): Effect<R0, E, A>;
+    <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <A, E>(self: Effect<A, E, R>) => Effect<A, E, R0>;
+    <A, E, R, R0>(self: Effect<A, E, R>, f: (context: Context.Context<R0>) => Context.Context<R>): Effect<A, E, R0>;
 };
 /**
  * Splits the context into two parts, providing one part using the
@@ -2259,12 +2258,12 @@ export declare const mapInputContext: {
  * @category context
  */
 export declare const provide: {
-    <R2, E2, A2>(layer: Layer.Layer<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | Exclude<R, A2>, E2 | E, A>;
-    <R2>(context: Context.Context<R2>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, R2>, E, A>;
-    <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, R2>, E, A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, layer: Layer.Layer<R2, E2, A2>): Effect<R2 | Exclude<R, A2>, E | E2, A>;
-    <R, E, A, R2>(self: Effect<R, E, A>, context: Context.Context<R2>): Effect<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(self: Effect<R, E, A>, runtime: Runtime.Runtime<R2>): Effect<Exclude<R, R2>, E, A>;
+    <R2, E2, R3>(layer: Layer.Layer<R3, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R2 | Exclude<R, R3>>;
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>;
+    <R2>(runtime: Runtime.Runtime<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>;
+    <A, E, R, R2, E2, R3>(self: Effect<A, E, R>, layer: Layer.Layer<R3, E2, R2>): Effect<A, E | E2, R2 | Exclude<R, R3>>;
+    <R, E, A, R2>(self: Effect<A, E, R>, context: Context.Context<R2>): Effect<A, E, Exclude<R, R2>>;
+    <R, E, A, R2>(self: Effect<A, E, R>, runtime: Runtime.Runtime<R2>): Effect<A, E, Exclude<R, R2>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -2274,8 +2273,8 @@ export declare const provide: {
  * @category context
  */
 export declare const provideService: {
-    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: Effect<R, E, A>, tag: T, service: Context.Tag.Service<T>): Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>>(self: Effect<A, E, R>, tag: T, service: Context.Tag.Service<T>): Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -2285,63 +2284,63 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceEffect: {
-    <T extends Context.Tag<any, any>, R1, E1>(tag: T, effect: Effect<R1, E1, Context.Tag.Service<T>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>;
-    <R, E, A, T extends Context.Tag<any, any>, R1, E1>(self: Effect<R, E, A>, tag: T, effect: Effect<R1, E1, Context.Tag.Service<T>>): Effect<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1, A>;
+    <T extends Context.Tag<any, any>, E1, R1>(tag: T, effect: Effect<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>, E1, R1>(self: Effect<A, E, R>, tag: T, effect: Effect<Context.Tag.Service<T>, E1, R1>): Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceFunction: <T extends Effect<any, any, any>, Args extends Array<any>, A>(getService: T, f: (_: Effect.Success<T>) => (...args: Args) => A) => (...args: Args) => Effect<Effect.Context<T>, Effect.Error<T>, A>;
+export declare const serviceFunction: <T extends Effect<any, any, any>, Args extends Array<any>, A>(getService: T, f: (_: Effect.Success<T>) => (...args: Args) => A) => (...args: Args) => Effect<A, Effect.Error<T>, Effect.Context<T>>;
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceFunctionEffect: <T extends Effect<any, any, any>, Args extends Array<any>, R, E, A>(getService: T, f: (_: Effect.Success<T>) => (...args: Args) => Effect<R, E, A>) => (...args: Args) => Effect<R | Effect.Context<T>, E | Effect.Error<T>, A>;
+export declare const serviceFunctionEffect: <T extends Effect<any, any, any>, Args extends Array<any>, R, E, A>(getService: T, f: (_: Effect.Success<T>) => (...args: Args) => Effect<A, E, R>) => (...args: Args) => Effect<A, E | Effect.Error<T>, R | Effect.Context<T>>;
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceFunctions: <SR, SE, S>(getService: Effect<SR, SE, S>) => {
+export declare const serviceFunctions: <S, SE, SR>(getService: Effect<S, SE, SR>) => {
     [k in {
         [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never;
-    }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer R, infer E, infer A> ? (...args: Args) => Effect<R | SR, E | SE, A> : never;
+    }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer A, infer E, infer R> ? (...args: Args) => Effect<A, SE | E, SR | R> : never;
 };
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceConstants: <SR, SE, S>(getService: Effect<SR, SE, S>) => {
+export declare const serviceConstants: <S, SE, SR>(getService: Effect<S, SE, SR>) => {
     [k in {
-        [k in keyof S]: S[k] extends Effect<any, any, any> ? k : never;
-    }[keyof S]]: S[k] extends Effect<infer R, infer E, infer A> ? Effect<R | SR, E | SE, A> : never;
+        [k in keyof S]: k;
+    }[keyof S]]: S[k] extends Effect<infer A, infer E, infer R> ? Effect<A, SE | E, SR | R> : Effect<S[k], SE, SR>;
 };
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceMembers: <SR, SE, S>(getService: Effect<SR, SE, S>) => {
+export declare const serviceMembers: <SR, SE, S>(getService: Effect<S, SE, SR>) => {
     functions: {
         [k in {
             [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never;
-        }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer R, infer E, infer A> ? (...args: Args) => Effect<R | SR, E | SE, A> : never;
+        }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer A, infer E, infer R> ? (...args: Args) => Effect<A, SE | E, SR | R> : never;
     };
     constants: {
         [k in {
-            [k in keyof S]: S[k] extends Effect<any, any, any> ? k : never;
-        }[keyof S]]: S[k] extends Effect<infer R, infer E, infer A> ? Effect<R | SR, E | SE, A> : never;
+            [k in keyof S]: k;
+        }[keyof S]]: S[k] extends Effect<infer A, infer E, infer R> ? Effect<A, SE | E, SR | R> : Effect<S[k], SE, SR>;
     };
 };
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Effect<never, never, Option.Option<S>>;
+export declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Effect<Option.Option<S>>;
 /**
  * @since 2.0.0
  * @category context
  */
-export declare const serviceOptional: <I, S>(tag: Context.Tag<I, S>) => Effect<never, Cause.NoSuchElementException, S>;
+export declare const serviceOptional: <I, S>(tag: Context.Tag<I, S>) => Effect<S, Cause.NoSuchElementException>;
 /**
  * Updates the service with the required service entry.
  *
@@ -2349,14 +2348,14 @@ export declare const serviceOptional: <I, S>(tag: Context.Tag<I, S>) => Effect<n
  * @category context
  */
 export declare const updateService: {
-    <T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): <R, E, A>(self: Effect<R, E, A>) => Effect<R | Context.Tag.Identifier<T>, E, A>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: Effect<R, E, A>, tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): Effect<R | Context.Tag.Identifier<T>, E, A>;
+    <T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R | Context.Tag.Identifier<T>>;
+    <A, E, R, T extends Context.Tag<any, any>>(self: Effect<A, E, R>, tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): Effect<A, E, R | Context.Tag.Identifier<T>>;
 };
 /**
  * @since 2.0.0
  * @category do notation
  */
-export declare const Do: Effect<never, never, {}>;
+export declare const Do: Effect<{}>;
 /**
  * Binds an effectful value in a `do` scope
  *
@@ -2364,28 +2363,28 @@ export declare const Do: Effect<never, never, {}>;
  * @category do notation
  */
 export declare const bind: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Effect<R2, E2, A>): <R, E>(self: Effect<R, E, K>) => Effect<R2 | R, E2 | E, MergeRecord<K, {
+    <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: K) => Effect<A, E2, R2>): <E, R>(self: Effect<K, E, R>) => Effect<MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, N extends string, K, R2, E2, A>(self: Effect<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Effect<R2, E2, A>): Effect<R | R2, E | E2, MergeRecord<K, {
+    }>, E2 | E, R2 | R>;
+    <K, E, R, N extends string, A, E2, R2>(self: Effect<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => Effect<A, E2, R2>): Effect<MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E2 | E, R2 | R>;
 };
 /**
  * @category do notation
  * @since 2.0.0
  */
 export declare const bindTo: {
-    <N extends string>(tag: N): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Record<N, A>>;
-    <R, E, A, N extends string>(self: Effect<R, E, A>, tag: N): Effect<R, E, Record<N, A>>;
+    <N extends string>(tag: N): <A, E, R>(self: Effect<A, E, R>) => Effect<Record<N, A>, E, R>;
+    <A, E, R, N extends string>(self: Effect<A, E, R>, tag: N): Effect<Record<N, A>, E, R>;
 };
 declare const let_: {
-    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Effect<R, E, K>) => Effect<R, E, MergeRecord<K, {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <E, R>(self: Effect<K, E, R>) => Effect<MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, K, N extends string, A>(self: Effect<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): Effect<R, E, MergeRecord<K, {
+    }>, E, R>;
+    <K, E, R, N extends string, A>(self: Effect<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): Effect<MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E, R>;
 };
 export { 
 /**
@@ -2408,12 +2407,12 @@ let_ as let };
  * @since 2.0.0
  * @category conversions
  */
-export declare const either: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Either.Either<E, A>>;
+export declare const either: <A, E, R>(self: Effect<A, E, R>) => Effect<Either.Either<E, A>, never, R>;
 /**
  * @since 2.0.0
  * @category conversions
  */
-export declare const exit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Exit.Exit<E, A>>;
+export declare const exit: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<A, E>, never, R>;
 /**
  * Returns an effect that will succeed or fail the specified `Deferred` based
  * upon the result of the effect. Also synchronizes interruption, so if the
@@ -2424,8 +2423,8 @@ export declare const exit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never,
  * @category conversions
  */
 export declare const intoDeferred: {
-    <E, A>(deferred: Deferred.Deferred<E, A>): <R>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
-    <R, E, A>(self: Effect<R, E, A>, deferred: Deferred.Deferred<E, A>): Effect<R, never, boolean>;
+    <A, E>(deferred: Deferred.Deferred<A, E>): <R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
+    <A, E, R>(self: Effect<A, E, R>, deferred: Deferred.Deferred<A, E>): Effect<boolean, never, R>;
 };
 /**
  * Executes this effect, skipping the error but returning optionally the
@@ -2434,20 +2433,20 @@ export declare const intoDeferred: {
  * @since 2.0.0
  * @category conversions
  */
-export declare const option: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Option.Option<A>>;
+export declare const option: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, never, R>;
 declare const if_: {
-    <R1, R2, E1, E2, A, A1>(options: {
-        readonly onTrue: Effect<R1, E1, A>;
-        readonly onFalse: Effect<R2, E2, A1>;
-    }): <R = never, E = never>(self: boolean | Effect<R, E, boolean>) => Effect<R1 | R2 | R, E1 | E2 | E, A | A1>;
-    <R1, R2, E1, E2, A, A1>(self: boolean, options: {
-        readonly onTrue: Effect<R1, E1, A>;
-        readonly onFalse: Effect<R2, E2, A1>;
-    }): Effect<R1 | R2, E1 | E2, A | A1>;
-    <R, E, R1, R2, E1, E2, A, A1>(self: Effect<R, E, boolean>, options: {
-        readonly onTrue: Effect<R1, E1, A>;
-        readonly onFalse: Effect<R2, E2, A1>;
-    }): Effect<R | R1 | R2, E | E1 | E2, A | A1>;
+    <A1, E1, R1, A2, E2, R2>(options: {
+        readonly onTrue: Effect<A1, E1, R1>;
+        readonly onFalse: Effect<A2, E2, R2>;
+    }): <E = never, R = never>(self: boolean | Effect<boolean, E, R>) => Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>;
+    <A1, E1, R1, A2, E2, R2>(self: boolean, options: {
+        readonly onTrue: Effect<A1, E1, R1>;
+        readonly onFalse: Effect<A2, E2, R2>;
+    }): Effect<A1 | A2, E1 | E2, R1 | R2>;
+    <E, R, A1, E1, R1, A2, E2, R2>(self: Effect<boolean, E, R>, options: {
+        readonly onTrue: Effect<A1, E1, R1>;
+        readonly onFalse: Effect<A2, E2, R2>;
+    }): Effect<A1 | A2, E | E1 | E2, R | R1 | R2>;
 };
 export { 
 /**
@@ -2465,10 +2464,10 @@ if_ as if };
  * @category filtering & conditionals
  */
 export declare const filterOrDie: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, orDieWith: (a: NoInfer<A>) => unknown): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>, orDieWith: (a: NoInfer<A>) => unknown): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A, B extends A>(self: Effect<R, E, A>, refinement: Refinement<A, B>, orDieWith: (a: A) => unknown): Effect<R, E, B>;
-    <R, E, A>(self: Effect<R, E, A>, filter: Predicate<A>, orDieWith: (a: A) => unknown): Effect<R, E, A>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, orDieWith: (a: NoInfer<A>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, orDieWith: (a: NoInfer<A>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orDieWith: (a: A) => unknown): Effect<B, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>, orDieWith: (a: A) => unknown): Effect<A, E, R>;
 };
 /**
  * Filter the specified effect with the provided function, dying with specified
@@ -2478,10 +2477,10 @@ export declare const filterOrDie: {
  * @category filtering & conditionals
  */
 export declare const filterOrDieMessage: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A, B extends A>(self: Effect<R, E, A>, refinement: Refinement<A, B>, message: string): Effect<R, E, B>;
-    <R, E, A>(self: Effect<R, E, A>, predicate: Predicate<A>, message: string): Effect<R, E, A>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>, message: string): Effect<B, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>, message: string): Effect<A, E, R>;
 };
 /**
  * Filters the specified effect with the provided function returning the value
@@ -2491,10 +2490,10 @@ export declare const filterOrDieMessage: {
  * @category filtering & conditionals
  */
 export declare const filterOrElse: {
-    <A, B extends A, R2, E2, C>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => Effect<R2, E2, C>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, B | C>;
-    <A, R2, E2, B>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => Effect<R2, E2, B>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A | B>;
-    <R, E, A, B extends A, R2, E2, C>(self: Effect<R, E, A>, refinement: Refinement<A, B>, orElse: (a: A) => Effect<R2, E2, C>): Effect<R | R2, E | E2, B | C>;
-    <R, E, A, R2, E2, B>(self: Effect<R, E, A>, predicate: Predicate<A>, orElse: (a: A) => Effect<R2, E2, B>): Effect<R | R2, E | E2, A | B>;
+    <A, B extends A, C, E2, R2>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => Effect<C, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<B | C, E2 | E, R2 | R>;
+    <A, B, E2, R2>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => Effect<B, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<A | B, E2 | E, R2 | R>;
+    <A, E, R, B extends A, C, E2, R2>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => Effect<C, E2, R2>): Effect<B | C, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Effect<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => Effect<B, E2, R2>): Effect<A | B, E | E2, R | R2>;
 };
 /**
  * Filter the specified effect with the provided function, failing with specified
@@ -2530,10 +2529,10 @@ export declare const filterOrElse: {
  * @category filtering & conditionals
  */
 export declare const filterOrFail: {
-    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: Effect<R, E, A>) => Effect<R, E2 | E, B>;
-    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <R, E>(self: Effect<R, E, A>) => Effect<R, E2 | E, A>;
-    <R, E, A, B extends A, E2>(self: Effect<R, E, A>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): Effect<R, E | E2, B>;
-    <R, E, A, E2>(self: Effect<R, E, A>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Effect<R, E | E2, A>;
+    <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R>;
+    <A, E, R, B extends A, E2>(self: Effect<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): Effect<B, E | E2, R>;
+    <A, E, R, E2>(self: Effect<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Effect<A, E | E2, R>;
 };
 /**
  * The moral equivalent of `if (!p) exp`.
@@ -2542,8 +2541,8 @@ export declare const filterOrFail: {
  * @category filtering & conditionals
  */
 export declare const unless: {
-    (condition: LazyArg<boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
-    <R, E, A>(self: Effect<R, E, A>, condition: LazyArg<boolean>): Effect<R, E, Option.Option<A>>;
+    (condition: LazyArg<boolean>): <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, condition: LazyArg<boolean>): Effect<Option.Option<A>, E, R>;
 };
 /**
  * The moral equivalent of `if (!p) exp` when `p` has side-effects.
@@ -2552,8 +2551,8 @@ export declare const unless: {
  * @category filtering & conditionals
  */
 export declare const unlessEffect: {
-    <R2, E2>(condition: Effect<R2, E2, boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, Option.Option<A>>;
-    <R, E, A, R2, E2>(self: Effect<R, E, A>, condition: Effect<R2, E2, boolean>): Effect<R | R2, E | E2, Option.Option<A>>;
+    <E2, R2>(condition: Effect<boolean, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Effect<A, E, R>, condition: Effect<boolean, E2, R2>): Effect<Option.Option<A>, E | E2, R | R2>;
 };
 /**
  * The moral equivalent of `if (p) exp`.
@@ -2562,16 +2561,16 @@ export declare const unlessEffect: {
  * @category filtering & conditionals
  */
 export declare const when: {
-    (condition: LazyArg<boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
-    <R, E, A>(self: Effect<R, E, A>, condition: LazyArg<boolean>): Effect<R, E, Option.Option<A>>;
+    (condition: LazyArg<boolean>): <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, condition: LazyArg<boolean>): Effect<Option.Option<A>, E, R>;
 };
 /**
  * @since 2.0.0
  * @category filtering & conditionals
  */
 export declare const whenEffect: {
-    <R, E>(condition: Effect<R, E, boolean>): <R2, E2, A>(effect: Effect<R2, E2, A>) => Effect<R | R2, E | E2, Option.Option<A>>;
-    <R, E, A, R2, E2>(self: Effect<R2, E2, A>, condition: Effect<R, E, boolean>): Effect<R | R2, E | E2, Option.Option<A>>;
+    <E, R>(condition: Effect<boolean, E, R>): <A, E2, R2>(effect: Effect<A, E2, R2>) => Effect<Option.Option<A>, E | E2, R | R2>;
+    <A, E2, R2, E, R>(self: Effect<A, E2, R2>, condition: Effect<boolean, E, R>): Effect<Option.Option<A>, E2 | E, R2 | R>;
 };
 /**
  * Executes this workflow when value of the specified `FiberRef` satisfies the
@@ -2581,8 +2580,8 @@ export declare const whenEffect: {
  * @category filtering & conditionals
  */
 export declare const whenFiberRef: {
-    <S>(fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, [S, Option.Option<A>]>;
-    <R, E, A, S>(self: Effect<R, E, A>, fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): Effect<R, E, [S, Option.Option<A>]>;
+    <S>(fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): <A, E, R>(self: Effect<A, E, R>) => Effect<[S, Option.Option<A>], E, R>;
+    <A, E, R, S>(self: Effect<A, E, R>, fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): Effect<[S, Option.Option<A>], E, R>;
 };
 /**
  * Executes this workflow when the value of the `Ref` satisfies the predicate.
@@ -2591,8 +2590,8 @@ export declare const whenFiberRef: {
  * @category filtering & conditionals
  */
 export declare const whenRef: {
-    <S>(ref: Ref.Ref<S>, predicate: Predicate<S>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, [S, Option.Option<A>]>;
-    <R, E, A, S>(self: Effect<R, E, A>, ref: Ref.Ref<S>, predicate: Predicate<S>): Effect<R, E, [S, Option.Option<A>]>;
+    <S>(ref: Ref.Ref<S>, predicate: Predicate<S>): <A, E, R>(self: Effect<A, E, R>) => Effect<[S, Option.Option<A>], E, R>;
+    <A, E, R, S>(self: Effect<A, E, R>, ref: Ref.Ref<S>, predicate: Predicate<S>): Effect<[S, Option.Option<A>], E, R>;
 };
 /**
  * This function is a pipeable operator that maps over an `Effect` value,
@@ -2608,8 +2607,8 @@ export declare const whenRef: {
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R1, E1, B>(f: (a: A) => Effect<R1, E1, B>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, B>;
-    <R, E, A, R1, E1, B>(self: Effect<R, E, A>, f: (a: A) => Effect<R1, E1, B>): Effect<R | R1, E | E1, B>;
+    <A, B, E1, R1>(f: (a: A) => Effect<B, E1, R1>): <E, R>(self: Effect<A, E, R>) => Effect<B, E1 | E, R1 | R>;
+    <A, E, R, B, E1, R1>(self: Effect<A, E, R>, f: (a: A) => Effect<B, E1, R1>): Effect<B, E | E1, R | R1>;
 };
 /**
  * Executes a sequence of two actions, typically two `Effect`s, where the second action can depend on the result of the first action.
@@ -2639,16 +2638,16 @@ export declare const flatMap: {
  * @category sequencing
  */
 export declare const andThen: {
-    <A, X>(f: (a: NoInfer<A>) => X): <R, E>(self: Effect<R, E, A>) => [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1> : [X] extends [Promise<infer A1>] ? Effect<R, E | Cause.UnknownException, A1> : Effect<R, E, X>;
-    <X>(f: X): <R, E, A>(self: Effect<R, E, A>) => [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1> : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1> : Effect<R, E, X>;
-    <A, R, E, X>(self: Effect<R, E, A>, f: (a: NoInfer<A>) => X): [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1> : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1> : Effect<R, E, X>;
-    <A, R, E, X>(self: Effect<R, E, A>, f: X): [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1> : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1> : Effect<R, E, X>;
+    <A, X>(f: (a: NoInfer<A>) => X): <E, R>(self: Effect<A, E, R>) => [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1> : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R> : Effect<X, E, R>;
+    <X>(f: X): <A, E, R>(self: Effect<A, E, R>) => [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1> : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R> : Effect<X, E, R>;
+    <A, R, E, X>(self: Effect<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1> : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R> : Effect<X, E, R>;
+    <A, R, E, X>(self: Effect<A, E, R>, f: X): [X] extends [Effect<infer A1, infer E1, infer R1>] ? Effect<A1, E | E1, R | R1> : [X] extends [Promise<infer A1>] ? Effect<A1, E | Cause.UnknownException, R> : Effect<X, E, R>;
 };
 /**
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flatten: <R, E, R1, E1, A>(self: Effect<R, E, Effect<R1, E1, A>>) => Effect<R | R1, E | E1, A>;
+export declare const flatten: <A, E1, R1, E, R>(self: Effect<Effect<A, E1, R1>, E, R>) => Effect<A, E | E1, R | R1>;
 /**
  * Returns an effect that races this effect with all the specified effects,
  * yielding the value of the first effect to succeed with a value. Losers of
@@ -2657,7 +2656,7 @@ export declare const flatten: <R, E, R1, E1, A>(self: Effect<R, E, Effect<R1, E1
  * @since 2.0.0
  * @category sequencing
  */
-export declare const raceAll: <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
+export declare const raceAll: <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<A, E, R>;
 /**
  * Returns an effect that races this effect with the specified effect,
  * returning the first successful `A` from the faster side. If one effect
@@ -2668,8 +2667,8 @@ export declare const raceAll: <R, E, A>(effects: Iterable<Effect<R, E, A>>) => E
  * @category sequencing
  */
 export declare const race: {
-    <R2, E2, A2>(that: Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+    <A2, E2, R2>(that: Effect<A2, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Returns an effect that races this effect with the specified effect,
@@ -2687,8 +2686,8 @@ export declare const race: {
  * @category sequencing
  */
 export declare const raceFirst: {
-    <R2, E2, A2>(that: Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+    <A2, E2, R2>(that: Effect<A2, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
  * Returns an effect that races this effect with the specified effect, calling
@@ -2698,14 +2697,14 @@ export declare const raceFirst: {
  * @category sequencing
  */
 export declare const raceWith: {
-    <E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(other: Effect<R1, E1, A1>, options: {
-        readonly onSelfDone: (exit: Exit.Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>;
-        readonly onOtherDone: (exit: Exit.Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>;
-    }): <R>(self: Effect<R, E, A>) => Effect<R1 | R2 | R3 | R, E2 | E3, A2 | A3>;
-    <R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, other: Effect<R1, E1, A1>, options: {
-        readonly onSelfDone: (exit: Exit.Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>;
-        readonly onOtherDone: (exit: Exit.Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>;
-    }): Effect<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
+    <A1, E1, R1, E, A, A2, E2, R2, A3, E3, R3>(other: Effect<A1, E1, R1>, options: {
+        readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect<A2, E2, R2>;
+        readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect<A3, E3, R3>;
+    }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, E2 | E3, R1 | R2 | R3 | R>;
+    <A, E, R, A1, E1, R1, A2, E2, R2, A3, E3, R3>(self: Effect<A, E, R>, other: Effect<A1, E1, R1>, options: {
+        readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect<A2, E2, R2>;
+        readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect<A3, E3, R3>;
+    }): Effect<A2 | A3, E2 | E3, R | R1 | R2 | R3>;
 };
 /**
  * Summarizes a effect by computing some value before and after execution, and
@@ -2716,18 +2715,18 @@ export declare const raceWith: {
  * @category sequencing
  */
 export declare const summarized: {
-    <R2, E2, B, C>(summary: Effect<R2, E2, B>, f: (start: B, end: B) => C): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, [C, A]>;
-    <R, E, A, R2, E2, B, C>(self: Effect<R, E, A>, summary: Effect<R2, E2, B>, f: (start: B, end: B) => C): Effect<R | R2, E | E2, [C, A]>;
+    <B, E2, R2, C>(summary: Effect<B, E2, R2>, f: (start: B, end: B) => C): <A, E, R>(self: Effect<A, E, R>) => Effect<[C, A], E2 | E, R2 | R>;
+    <A, E, R, B, E2, R2, C>(self: Effect<A, E, R>, summary: Effect<B, E2, R2>, f: (start: B, end: B) => C): Effect<[C, A], E2 | E, R2 | R>;
 };
 /**
  * @since 2.0.0
  * @category sequencing
  */
 export declare const tap: {
-    <A, X>(f: (a: NoInfer<A>) => X): <R, E>(self: Effect<R, E, A>) => [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A> : [X] extends [Promise<infer _A1>] ? Effect<R, E | Cause.UnknownException, A> : Effect<R, E, A>;
-    <X>(f: X): <R, E, A>(self: Effect<R, E, A>) => [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A> : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A> : Effect<R, E, A>;
-    <A, R, E, X>(self: Effect<R, E, A>, f: (a: NoInfer<A>) => X): [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A> : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A> : Effect<R, E, A>;
-    <A, R, E, X>(self: Effect<R, E, A>, f: X): [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A> : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A> : Effect<R, E, A>;
+    <A, X>(f: (a: NoInfer<A>) => X): <E, R>(self: Effect<A, E, R>) => [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1> : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R> : Effect<A, E, R>;
+    <X>(f: X): <A, E, R>(self: Effect<A, E, R>) => [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1> : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R> : Effect<A, E, R>;
+    <A, E, R, X>(self: Effect<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1> : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R> : Effect<A, E, R>;
+    <A, E, R, X>(self: Effect<A, E, R>, f: X): [X] extends [Effect<infer _A1, infer E1, infer R1>] ? Effect<A, E | E1, R | R1> : [X] extends [Promise<infer _A1>] ? Effect<A, E | Cause.UnknownException, R> : Effect<A, E, R>;
 };
 /**
  * Returns an effect that effectfully "peeks" at the failure or success of
@@ -2737,14 +2736,14 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapBoth: {
-    <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(options: {
-        readonly onFailure: (e: XE) => Effect<R2, E2, X>;
-        readonly onSuccess: (a: XA) => Effect<R3, E3, X1>;
-    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E | E2 | E3, A>;
-    <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(self: Effect<R, E, A>, options: {
-        readonly onFailure: (e: XE) => Effect<R2, E2, X>;
-        readonly onSuccess: (a: XA) => Effect<R3, E3, X1>;
-    }): Effect<R | R2 | R3, E | E2 | E3, A>;
+    <E, X, E2, R2, A, X1, E3, R3>(options: {
+        readonly onFailure: (e: NoInfer<E>) => Effect<X, E2, R2>;
+        readonly onSuccess: (a: NoInfer<A>) => Effect<X1, E3, R3>;
+    }): <R>(self: Effect<A, E, R>) => Effect<A, E | E2 | E3, R2 | R3 | R>;
+    <A, E, R, X, E2, R2, X1, E3, R3>(self: Effect<A, E, R>, options: {
+        readonly onFailure: (e: E) => Effect<X, E2, R2>;
+        readonly onSuccess: (a: A) => Effect<X1, E3, R3>;
+    }): Effect<A, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * Returns an effect that effectually "peeks" at the defect of this effect.
@@ -2753,8 +2752,8 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapDefect: {
-    <R2, E2, X>(f: (cause: Cause.Cause<never>) => Effect<R2, E2, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, X>(self: Effect<R, E, A>, f: (cause: Cause.Cause<never>) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+    <X, E2, R2>(f: (cause: Cause.Cause<never>) => Effect<X, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<never>) => Effect<X, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
  * Returns an effect that effectfully "peeks" at the failure of this effect.
@@ -2763,8 +2762,8 @@ export declare const tapDefect: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, XE extends E, R2, E2, X>(f: (e: XE) => Effect<R2, E2, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A>;
-    <R, E, XE extends E, A, R2, E2, X>(self: Effect<R, E, A>, f: (e: XE) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+    <E, X, E2, R2>(f: (e: NoInfer<E>) => Effect<X, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Effect<A, E, R>, f: (e: E) => Effect<X, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
  * Returns an effect that effectfully "peeks" at the specific tagged failure of this effect.
@@ -2773,16 +2772,16 @@ export declare const tapError: {
  * @category sequencing
  */
 export declare const tapErrorTag: {
-    <K extends (E extends {
+    <K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never), E, R1, E1, A1>(k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Effect<R1, E1, A1>): <R, A>(self: Effect<R, E, A>) => Effect<R | R1, E | E1, A>;
-    <R, E, A, K extends (E extends {
+    }>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E1, R1 | R>;
+    <A, E, R, K extends E extends {
         _tag: string;
-    } ? E["_tag"] : never), R1, E1, A1>(self: Effect<R, E, A>, k: K, f: (e: Extract<E, {
+    } ? E["_tag"] : never, A1, E1, R1>(self: Effect<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Effect<R1, E1, A1>): Effect<R | R1, E | E1, A>;
+    }>) => Effect<A1, E1, R1>): Effect<A, E | E1, R | R1>;
 };
 /**
  * Returns an effect that effectually "peeks" at the cause of the failure of
@@ -2792,8 +2791,8 @@ export declare const tapErrorTag: {
  * @category sequencing
  */
 export declare const tapErrorCause: {
-    <E, XE extends E, R2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<R2, E2, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A>;
-    <R, E, A, XE extends E, R2, E2, X>(self: Effect<R, E, A>, f: (cause: Cause.Cause<XE>) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+    <E, X, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect<X, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Effect<X, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
  * Repeats this effect forever (until the first error).
@@ -2801,7 +2800,7 @@ export declare const tapErrorCause: {
  * @since 2.0.0
  * @category repetition / recursion
  */
-export declare const forever: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, never>;
+export declare const forever: <A, E, R>(self: Effect<A, E, R>) => Effect<never, E, R>;
 /**
  * The `Effect.iterate` function allows you to iterate with an effectful operation. It uses an effectful `body` operation to change the state during each iteration and continues the iteration as long as the `while` function evaluates to `true`:
  *
@@ -2827,12 +2826,12 @@ export declare const forever: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, n
 export declare const iterate: {
     <A, B extends A, R, E>(initial: A, options: {
         readonly while: Refinement<A, B>;
-        readonly body: (b: B) => Effect<R, E, A>;
-    }): Effect<R, E, A>;
+        readonly body: (b: B) => Effect<A, E, R>;
+    }): Effect<A, E, R>;
     <A, R, E>(initial: A, options: {
-        readonly while: (a: A) => boolean;
-        readonly body: (a: A) => Effect<R, E, A>;
-    }): Effect<R, E, A>;
+        readonly while: Predicate<A>;
+        readonly body: (a: A) => Effect<A, E, R>;
+    }): Effect<A, E, R>;
 };
 /**
  * The `Effect.loop` function allows you to repeatedly change the state based on an `step` function until a condition given by the `while` function is evaluated to `true`:
@@ -2861,30 +2860,30 @@ export declare const iterate: {
  * @category repetition / recursion
  */
 export declare const loop: {
-    <A, B extends A, R, E, C>(initial: A, options: {
+    <A, B extends A, C, E, R>(initial: A, options: {
         readonly while: Refinement<A, B>;
         readonly step: (b: B) => A;
-        readonly body: (b: B) => Effect<R, E, C>;
+        readonly body: (b: B) => Effect<C, E, R>;
         readonly discard?: false | undefined;
-    }): Effect<R, E, Array<C>>;
-    <A, R, E, C>(initial: A, options: {
+    }): Effect<Array<C>, E, R>;
+    <A, C, E, R>(initial: A, options: {
         readonly while: (a: A) => boolean;
         readonly step: (a: A) => A;
-        readonly body: (a: A) => Effect<R, E, C>;
+        readonly body: (a: A) => Effect<C, E, R>;
         readonly discard?: false | undefined;
-    }): Effect<R, E, Array<C>>;
-    <A, B extends A, R, E, C>(initial: A, options: {
+    }): Effect<Array<C>, E, R>;
+    <A, B extends A, C, E, R>(initial: A, options: {
         readonly while: Refinement<A, B>;
         readonly step: (b: B) => A;
-        readonly body: (b: B) => Effect<R, E, C>;
+        readonly body: (b: B) => Effect<C, E, R>;
         readonly discard: true;
-    }): Effect<R, E, void>;
-    <A, R, E, C>(initial: A, options: {
+    }): Effect<void, E, R>;
+    <A, C, E, R>(initial: A, options: {
         readonly while: (a: A) => boolean;
         readonly step: (a: A) => A;
-        readonly body: (a: A) => Effect<R, E, C>;
+        readonly body: (a: A) => Effect<C, E, R>;
         readonly discard: true;
-    }): Effect<R, E, void>;
+    }): Effect<void, E, R>;
 };
 /**
  * @since 2.0.0
@@ -2895,30 +2894,30 @@ export declare namespace Repeat {
      * @since 2.0.0
      * @category repetition / recursion
      */
-    type Return<R, E, A, O extends Options<A>> = Effect<R | (O extends {
-        schedule: Schedule.Schedule<infer X, infer _I, infer _O>;
-    } ? X : never) | (O extends {
-        while: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
-    } ? X : never) | (O extends {
-        until: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
-    } ? X : never), E | (O extends {
-        while: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
-    } ? X : never) | (O extends {
-        until: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
-    } ? X : never), (O extends {
+    type Return<R, E, A, O extends Options<A>> = Effect<(O extends {
         schedule: Schedule.Schedule<infer _R, infer _I, infer Out>;
     } ? Out : O extends {
         until: Refinement<A, infer B>;
-    } ? B : A)> extends infer Z ? Z : never;
+    } ? B : A), E | (O extends {
+        while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
+    } ? E : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
+    } ? E : never), R | (O extends {
+        schedule: Schedule.Schedule<infer R, infer _I, infer _O>;
+    } ? R : never) | (O extends {
+        while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R>;
+    } ? R : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R>;
+    } ? R : never)> extends infer Z ? Z : never;
     /**
      * @since 2.0.0
      * @category repetition / recursion
      */
     interface Options<A> {
-        while?: (_: A) => boolean | Effect<any, any, boolean>;
-        until?: (_: A) => boolean | Effect<any, any, boolean>;
-        times?: number;
-        schedule?: Schedule.Schedule<any, A, any>;
+        while?: ((_: A) => boolean | Effect<boolean, any, any>) | undefined;
+        until?: ((_: A) => boolean | Effect<boolean, any, any>) | undefined;
+        times?: number | undefined;
+        schedule?: Schedule.Schedule<any, A, any> | undefined;
     }
 }
 /**
@@ -2932,10 +2931,10 @@ export declare namespace Repeat {
  * @category repetition / recursion
  */
 export declare const repeat: {
-    <A, O extends Repeat.Options<A>>(options: O): <R, E>(self: Effect<R, E, A>) => Repeat.Return<R, E, A, O>;
-    <R1, A extends A0, A0, B>(schedule: Schedule.Schedule<R1, A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E, B>;
-    <R, E, A, O extends Repeat.Options<A>>(self: Effect<R, E, A>, options: O): Repeat.Return<R, E, A, O>;
-    <R, E, A extends A0, A0, R1, B>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R1, A0, B>): Effect<R | R1, E, B>;
+    <A, O extends Repeat.Options<A>>(options: O): <E, R>(self: Effect<A, E, R>) => Repeat.Return<R, E, A, O>;
+    <R1, A, B>(schedule: Schedule.Schedule<R1, A, B>): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R1 | R>;
+    <A, E, R, O extends Repeat.Options<A>>(self: Effect<A, E, R>, options: O): Repeat.Return<R, E, A, O>;
+    <A, E, R, R1, B>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R1, A, B>): Effect<B, E, R | R1>;
 };
 /**
  * Returns a new effect that repeats this effect the specified number of times
@@ -2947,8 +2946,8 @@ export declare const repeat: {
  * @category repetition / recursion
  */
 export declare const repeatN: {
-    (n: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, n: number): Effect<R, E, A>;
+    (n: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, n: number): Effect<A, E, R>;
 };
 /**
  * Returns a new effect that repeats this effect according to the specified
@@ -2963,8 +2962,8 @@ export declare const repeatN: {
  * @category repetition / recursion
  */
 export declare const repeatOrElse: {
-    <R2, A extends A0, A0, B, E, R3, E2>(schedule: Schedule.Schedule<R2, A, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2, B>;
-    <R, E, A extends A0, A0, R2, B, R3, E2>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, A0, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): Effect<R | R2 | R3, E2, B>;
+    <R2, A, B, E, E2, R3>(schedule: Schedule.Schedule<R2, A, B>, orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>): <R>(self: Effect<A, E, R>) => Effect<B, E2, R2 | R3 | R>;
+    <A, E, R, R2, B, E2, R3>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R2, A, B>, orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>): Effect<B, E2, R | R2 | R3>;
 };
 /**
  * Runs this effect according to the specified schedule.
@@ -2976,8 +2975,8 @@ export declare const repeatOrElse: {
  * @category repetition / recursion
  */
 export declare const schedule: {
-    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, Out>;
-    <R, E, A, R2, Out>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<R | R2, E, Out>;
+    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>;
+    <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Out, E, R | R2>;
 };
 /**
  * Runs this effect according to the specified schedule in a new fiber
@@ -2987,8 +2986,8 @@ export declare const schedule: {
  * @category repetition / recursion
  */
 export declare const scheduleForked: {
-    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<E, Out>>;
-    <R, E, A, R2, Out>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<E, Out>>;
+    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <A, E, R>(self: Effect<A, E, R>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<Out, E>>;
+    <R, E, A, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<Out, E>>;
 };
 /**
  * Runs this effect according to the specified schedule starting from the
@@ -2998,18 +2997,18 @@ export declare const scheduleForked: {
  * @category repetition / recursion
  */
 export declare const scheduleFrom: {
-    <R2, In, Out>(initial: In, schedule: Schedule.Schedule<R2, In, Out>): <R, E>(self: Effect<R, E, In>) => Effect<R2 | R, E, Out>;
-    <R, E, In, R2, Out>(self: Effect<R, E, In>, initial: In, schedule: Schedule.Schedule<R2, In, Out>): Effect<R | R2, E, Out>;
+    <R2, In, Out>(initial: In, schedule: Schedule.Schedule<R2, In, Out>): <E, R>(self: Effect<In, E, R>) => Effect<Out, E, R2 | R>;
+    <In, E, R, R2, Out>(self: Effect<In, E, R>, initial: In, schedule: Schedule.Schedule<R2, In, Out>): Effect<Out, E, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category repetition / recursion
  */
-export declare const whileLoop: <R, E, A>(options: {
+export declare const whileLoop: <A, E, R>(options: {
     readonly while: LazyArg<boolean>;
-    readonly body: LazyArg<Effect<R, E, A>>;
+    readonly body: LazyArg<Effect<A, E, R>>;
     readonly step: (a: A) => void;
-}) => Effect<R, E, void>;
+}) => Effect<void, E, R>;
 /**
  * Returns a collection of all `FiberRef` values for the fiber running this
  * effect.
@@ -3017,45 +3016,45 @@ export declare const whileLoop: <R, E, A>(options: {
  * @since 2.0.0
  * @category fiber refs
  */
-export declare const getFiberRefs: Effect<never, never, FiberRefs.FiberRefs>;
+export declare const getFiberRefs: Effect<FiberRefs.FiberRefs>;
 /**
  * Inherits values from all `FiberRef` instances into current fiber.
  *
  * @since 2.0.0
  * @category fiber refs
  */
-export declare const inheritFiberRefs: (childFiberRefs: FiberRefs.FiberRefs) => Effect<never, never, void>;
+export declare const inheritFiberRefs: (childFiberRefs: FiberRefs.FiberRefs) => Effect<void>;
 /**
  * @since 2.0.0
  * @category fiber refs
  */
 export declare const locally: {
-    <A>(self: FiberRef.FiberRef<A>, value: A): <R, E, B>(use: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B, A>(use: Effect<R, E, B>, self: FiberRef.FiberRef<A>, value: A): Effect<R, E, B>;
+    <A>(self: FiberRef.FiberRef<A>, value: A): <B, E, R>(use: Effect<B, E, R>) => Effect<B, E, R>;
+    <B, E, R, A>(use: Effect<B, E, R>, self: FiberRef.FiberRef<A>, value: A): Effect<B, E, R>;
 };
 /**
  * @since 2.0.0
  * @category fiber refs
  */
 export declare const locallyWith: {
-    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <R, E, B>(use: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B, A>(use: Effect<R, E, B>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<R, E, B>;
+    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <B, E, R>(use: Effect<B, E, R>) => Effect<B, E, R>;
+    <B, E, R, A>(use: Effect<B, E, R>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<B, E, R>;
 };
 /**
  * @since 2.0.0
  * @category fiber refs
  */
 export declare const locallyScoped: {
-    <A>(value: A): (self: FiberRef.FiberRef<A>) => Effect<Scope.Scope, never, void>;
-    <A>(self: FiberRef.FiberRef<A>, value: A): Effect<Scope.Scope, never, void>;
+    <A>(value: A): (self: FiberRef.FiberRef<A>) => Effect<void, never, Scope.Scope>;
+    <A>(self: FiberRef.FiberRef<A>, value: A): Effect<void, never, Scope.Scope>;
 };
 /**
  * @since 2.0.0
  * @category fiber refs
  */
 export declare const locallyScopedWith: {
-    <A>(f: (a: A) => A): (self: FiberRef.FiberRef<A>) => Effect<Scope.Scope, never, void>;
-    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<Scope.Scope, never, void>;
+    <A>(f: (a: A) => A): (self: FiberRef.FiberRef<A>) => Effect<void, never, Scope.Scope>;
+    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<void, never, Scope.Scope>;
 };
 /**
  * Applies the specified changes to the `FiberRef` values for the fiber
@@ -3064,7 +3063,7 @@ export declare const locallyScopedWith: {
  * @since 2.0.0
  * @category fiber refs
  */
-export declare const patchFiberRefs: (patch: FiberRefsPatch.FiberRefsPatch) => Effect<never, never, void>;
+export declare const patchFiberRefs: (patch: FiberRefsPatch.FiberRefsPatch) => Effect<void>;
 /**
  * Sets the `FiberRef` values for the fiber running this effect to the values
  * in the specified collection of `FiberRef` values.
@@ -3072,7 +3071,7 @@ export declare const patchFiberRefs: (patch: FiberRefsPatch.FiberRefsPatch) => E
  * @since 2.0.0
  * @category fiber refs
  */
-export declare const setFiberRefs: (fiberRefs: FiberRefs.FiberRefs) => Effect<never, never, void>;
+export declare const setFiberRefs: (fiberRefs: FiberRefs.FiberRefs) => Effect<void>;
 /**
  * Updates the `FiberRef` values for the fiber running this effect using the
  * specified function.
@@ -3080,21 +3079,21 @@ export declare const setFiberRefs: (fiberRefs: FiberRefs.FiberRefs) => Effect<ne
  * @since 2.0.0
  * @category fiber refs
  */
-export declare const updateFiberRefs: (f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs) => Effect<never, never, void>;
+export declare const updateFiberRefs: (f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs) => Effect<void>;
 /**
  * Returns `true` if this effect is a failure, `false` otherwise.
  *
  * @since 2.0.0
  * @category getters & folding
  */
-export declare const isFailure: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
+export declare const isFailure: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
 /**
  * Returns `true` if this effect is a success, `false` otherwise.
  *
  * @since 2.0.0
  * @category getters & folding
  */
-export declare const isSuccess: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
+export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
 /**
  * Folds over the failure value or the success value to yield an effect that
  * does not fail, but succeeds with the value returned by the left or right
@@ -3104,14 +3103,14 @@ export declare const isSuccess: <R, E, A>(self: Effect<R, E, A>) => Effect<R, ne
  * @category getters & folding
  */
 export declare const match: {
-    <E, A, A2, A3>(options: {
+    <E, A2, A, A3>(options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
-    }): <R>(self: Effect<R, E, A>) => Effect<R, never, A2 | A3>;
-    <R, E, A, A2, A3>(self: Effect<R, E, A>, options: {
+    }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, never, R>;
+    <A, E, R, A2, A3>(self: Effect<A, E, R>, options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
-    }): Effect<R, never, A2 | A3>;
+    }): Effect<A2 | A3, never, R>;
 };
 /**
  * @since 2.0.0
@@ -3121,39 +3120,39 @@ export declare const matchCause: {
     <E, A2, A, A3>(options: {
         readonly onFailure: (cause: Cause.Cause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
-    }): <R>(self: Effect<R, E, A>) => Effect<R, never, A2 | A3>;
-    <R, E, A2, A, A3>(self: Effect<R, E, A>, options: {
+    }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, never, R>;
+    <A, E, R, A2, A3>(self: Effect<A, E, R>, options: {
         readonly onFailure: (cause: Cause.Cause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
-    }): Effect<R, never, A2 | A3>;
+    }): Effect<A2 | A3, never, R>;
 };
 /**
  * @since 2.0.0
  * @category getters & folding
  */
 export declare const matchCauseEffect: {
-    <E, A, R2, E2, A2, R3, E3, A3>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>;
-        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
-    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E3, A2 | A3>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>;
-        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
-    }): Effect<R | R2 | R3, E2 | E3, A2 | A3>;
+    <E, A2, E2, R2, A, A3, E3, R3>(options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => Effect<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Effect<A3, E3, R3>;
+    }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, E2 | E3, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, A3, E3, R3>(self: Effect<A, E, R>, options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => Effect<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Effect<A3, E3, R3>;
+    }): Effect<A2 | A3, E2 | E3, R2 | R3 | R>;
 };
 /**
  * @since 2.0.0
  * @category getters & folding
  */
 export declare const matchEffect: {
-    <E, A, R2, E2, A2, R3, E3, A3>(options: {
-        readonly onFailure: (e: E) => Effect<R2, E2, A2>;
-        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
-    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E3, A2 | A3>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, options: {
-        readonly onFailure: (e: E) => Effect<R2, E2, A2>;
-        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
-    }): Effect<R | R2 | R3, E2 | E3, A2 | A3>;
+    <E, A2, E2, R2, A, A3, E3, R3>(options: {
+        readonly onFailure: (e: E) => Effect<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Effect<A3, E3, R3>;
+    }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, E2 | E3, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, A3, E3, R3>(self: Effect<A, E, R>, options: {
+        readonly onFailure: (e: E) => Effect<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Effect<A3, E3, R3>;
+    }): Effect<A2 | A3, E2 | E3, R2 | R3 | R>;
 };
 /**
  * Logs the specified message or cause at the current log level.
@@ -3163,49 +3162,49 @@ export declare const matchEffect: {
  * @since 2.0.0
  * @category logging
  */
-export declare const log: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const log: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Trace log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logTrace: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logTrace: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Debug log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logDebug: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logDebug: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Info log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logInfo: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logInfo: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Warning log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logWarning: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logWarning: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Error log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logError: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logError: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Logs the specified message or cause at the Fatal log level.
  *
  * @since 2.0.0
  * @category logging
  */
-export declare const logFatal: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+export declare const logFatal: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<void>;
 /**
  * Adjusts the label for the current logging span.
  *
@@ -3213,8 +3212,8 @@ export declare const logFatal: <A>(messageOrCause: A, supplementary?: A extends
  * @category logging
  */
 export declare const withLogSpan: {
-    (label: string): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, label: string): Effect<R, E, A>;
+    (label: string): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, label: string): Effect<A, E, R>;
 };
 /**
  * Annotates each log in this effect with the specified log annotation.
@@ -3223,10 +3222,10 @@ export declare const withLogSpan: {
  * @category logging
  */
 export declare const annotateLogs: {
-    (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>;
+    (key: string, value: unknown): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    (values: Record<string, unknown>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
 };
 /**
  * Retrieves the log annotations associated with the current scope.
@@ -3234,7 +3233,7 @@ export declare const annotateLogs: {
  * @since 2.0.0
  * @category logging
  */
-export declare const logAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>>;
+export declare const logAnnotations: Effect<HashMap.HashMap<string, unknown>>;
 /**
  * Decides wether child fibers will report or not unhandled errors via the logger
  *
@@ -3242,8 +3241,8 @@ export declare const logAnnotations: Effect<never, never, HashMap.HashMap<string
  * @category logging
  */
 export declare const withUnhandledErrorLogLevel: {
-    (level: Option.Option<LogLevel>): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
-    <R, E, B>(self: Effect<R, E, B>, level: Option.Option<LogLevel>): Effect<R, E, B>;
+    (level: Option.Option<LogLevel>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, level: Option.Option<LogLevel>): Effect<A, E, R>;
 };
 /**
  * Translates effect failure into death of the fiber, making all failures
@@ -3252,7 +3251,7 @@ export declare const withUnhandledErrorLogLevel: {
  * @since 2.0.0
  * @category alternatives
  */
-export declare const orDie: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
+export declare const orDie: <A, E, R>(self: Effect<A, E, R>) => Effect<A, never, R>;
 /**
  * Keeps none of the errors, and terminates the fiber with them, using the
  * specified function to convert the `E` into a `Throwable`.
@@ -3261,8 +3260,8 @@ export declare const orDie: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never,
  * @category alternatives
  */
 export declare const orDieWith: {
-    <E>(f: (error: E) => unknown): <R, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
-    <R, E, A>(self: Effect<R, E, A>, f: (error: E) => unknown): Effect<R, never, A>;
+    <E>(f: (error: E) => unknown): <A, R>(self: Effect<A, E, R>) => Effect<A, never, R>;
+    <A, E, R>(self: Effect<A, E, R>, f: (error: E) => unknown): Effect<A, never, R>;
 };
 /**
  * Executes this effect and returns its value, if it succeeds, but otherwise
@@ -3272,8 +3271,8 @@ export declare const orDieWith: {
  * @category alternatives
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<Effect<R2, E2, A2>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: LazyArg<Effect<R2, E2, A2>>): Effect<R | R2, E2, A | A2>;
+    <A2, E2, R2>(that: LazyArg<Effect<A2, E2, R2>>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: LazyArg<Effect<A2, E2, R2>>): Effect<A2 | A, E2, R2 | R>;
 };
 /**
  * Executes this effect and returns its value, if it succeeds, but otherwise
@@ -3283,8 +3282,8 @@ export declare const orElse: {
  * @category alternatives
  */
 export declare const orElseFail: {
-    <E2>(evaluate: LazyArg<E2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
-    <R, E, A, E2>(self: Effect<R, E, A>, evaluate: LazyArg<E2>): Effect<R, E2, A>;
+    <E2>(evaluate: LazyArg<E2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
+    <A, E, R, E2>(self: Effect<A, E, R>, evaluate: LazyArg<E2>): Effect<A, E2, R>;
 };
 /**
  * Executes this effect and returns its value, if it succeeds, but
@@ -3294,8 +3293,8 @@ export declare const orElseFail: {
  * @category alternatives
  */
 export declare const orElseSucceed: {
-    <A2>(evaluate: LazyArg<A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A2 | A>;
-    <R, E, A, A2>(self: Effect<R, E, A>, evaluate: LazyArg<A2>): Effect<R, never, A | A2>;
+    <A2>(evaluate: LazyArg<A2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A2 | A, never, R>;
+    <A, E, R, A2>(self: Effect<A, E, R>, evaluate: LazyArg<A2>): Effect<A | A2, never, R>;
 };
 /**
  * Retreives the `Random` service from the context.
@@ -3303,7 +3302,7 @@ export declare const orElseSucceed: {
  * @since 2.0.0
  * @category random
  */
-export declare const random: Effect<never, never, Random.Random>;
+export declare const random: Effect<Random.Random>;
 /**
  * Retreives the `Random` service from the context and uses it to run the
  * specified workflow.
@@ -3311,7 +3310,7 @@ export declare const random: Effect<never, never, Random.Random>;
  * @since 2.0.0
  * @category random
  */
-export declare const randomWith: <R, E, A>(f: (random: Random.Random) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const randomWith: <A, E, R>(f: (random: Random.Random) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Returns an effect that accesses the runtime, which can be used to
  * (unsafely) execute tasks. This is useful for integration with legacy code
@@ -3320,7 +3319,7 @@ export declare const randomWith: <R, E, A>(f: (random: Random.Random) => Effect<
  * @since 2.0.0
  * @category runtime
  */
-export declare const runtime: <R>() => Effect<R, never, Runtime.Runtime<R>>;
+export declare const runtime: <R>() => Effect<Runtime.Runtime<R>, never, R>;
 /**
  * Retrieves an effect that succeeds with the current runtime flags, which
  * govern behavior and features of the runtime system.
@@ -3328,25 +3327,25 @@ export declare const runtime: <R>() => Effect<R, never, Runtime.Runtime<R>>;
  * @since 2.0.0
  * @category runtime
  */
-export declare const getRuntimeFlags: Effect<never, never, RuntimeFlags.RuntimeFlags>;
+export declare const getRuntimeFlags: Effect<RuntimeFlags.RuntimeFlags>;
 /**
  * @since 2.0.0
  * @category runtime
  */
-export declare const patchRuntimeFlags: (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<never, never, void>;
+export declare const patchRuntimeFlags: (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<void>;
 /**
  * @since 2.0.0
  * @category runtime
  */
 export declare const withRuntimeFlagsPatch: {
-    (update: RuntimeFlagsPatch.RuntimeFlagsPatch): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, update: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect<R, E, A>;
+    (update: RuntimeFlagsPatch.RuntimeFlagsPatch): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, update: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category runtime
  */
-export declare const withRuntimeFlagsPatchScoped: (update: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<Scope.Scope, never, void>;
+export declare const withRuntimeFlagsPatchScoped: (update: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<void, never, Scope.Scope>;
 /**
  * Tags each metric in this effect with the specific tag.
  *
@@ -3354,10 +3353,10 @@ export declare const withRuntimeFlagsPatchScoped: (update: RuntimeFlagsPatch.Run
  * @category metrics
  */
 export declare const tagMetrics: {
-    (key: string, value: string): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    (values: Record<string, string>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, key: string, value: string): Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, string>): Effect<R, E, A>;
+    (key: string, value: string): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    (values: Record<string, string>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, key: string, value: string): Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, values: Record<string, string>): Effect<A, E, R>;
 };
 /**
  * Tags each metric in this effect with the specific tag.
@@ -3366,8 +3365,8 @@ export declare const tagMetrics: {
  * @category metrics
  */
 export declare const labelMetrics: {
-    (labels: Iterable<MetricLabel.MetricLabel>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>): Effect<R, E, A>;
+    (labels: Iterable<MetricLabel.MetricLabel>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, labels: Iterable<MetricLabel.MetricLabel>): Effect<A, E, R>;
 };
 /**
  * Tags each metric in a scope with a the specific tag.
@@ -3375,28 +3374,28 @@ export declare const labelMetrics: {
  * @since 2.0.0
  * @category metrics
  */
-export declare const tagMetricsScoped: (key: string, value: string) => Effect<Scope.Scope, never, void>;
+export declare const tagMetricsScoped: (key: string, value: string) => Effect<void, never, Scope.Scope>;
 /**
  * Tags each metric in a scope with a the specific tag.
  *
  * @since 2.0.0
  * @category metrics
  */
-export declare const labelMetricsScoped: (labels: ReadonlyArray<MetricLabel.MetricLabel>) => Effect<Scope.Scope, never, void>;
+export declare const labelMetricsScoped: (labels: ReadonlyArray<MetricLabel.MetricLabel>) => Effect<void, never, Scope.Scope>;
 /**
  * Retrieves the metric labels associated with the current scope.
  *
  * @since 2.0.0
  * @category metrics
  */
-export declare const metricLabels: Effect<never, never, ReadonlyArray<MetricLabel.MetricLabel>>;
+export declare const metricLabels: Effect<ReadonlyArray<MetricLabel.MetricLabel>>;
 /**
  * @since 2.0.0
  * @category metrics
  */
 export declare const withMetric: {
-    <Type, In, Out>(metric: Metric.Metric<Type, In, Out>): <R, E, A extends In>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A extends In, Type, In, Out>(self: Effect<R, E, A>, metric: Metric.Metric<Type, In, Out>): Effect<R, E, A>;
+    <Type, In, Out>(metric: Metric.Metric<Type, In, Out>): <R, E, A extends In>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <R, E, A extends In, Type, In, Out>(self: Effect<A, E, R>, metric: Metric.Metric<Type, In, Out>): Effect<A, E, R>;
 };
 /**
  * Used to unify functions that would otherwise return `Effect<A, B, C> | Effect<D, E, F>`
@@ -3424,10 +3423,10 @@ export interface Permit {
  * @since 2.0.0
  */
 export interface Semaphore {
-    withPermits(permits: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    take(permits: number): Effect<never, never, number>;
-    release(permits: number): Effect<never, never, void>;
-    releaseAll: Effect<never, never, void>;
+    withPermits(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    take(permits: number): Effect<number>;
+    release(permits: number): Effect<void>;
+    releaseAll: Effect<void>;
 }
 /**
  * Unsafely creates a new Semaphore
@@ -3442,17 +3441,17 @@ export declare const unsafeMakeSemaphore: (permits: number) => Semaphore;
  * @since 2.0.0
  * @category semaphore
  */
-export declare const makeSemaphore: (permits: number) => Effect<never, never, Semaphore>;
+export declare const makeSemaphore: (permits: number) => Effect<Semaphore>;
 /**
  * @since 2.0.0
  * @category execution
  */
-export declare const runFork: <E, A>(effect: Effect<never, E, A>, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber<E, A>;
+export declare const runFork: <A, E>(effect: Effect<A, E>, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber<A, E>;
 /**
  * @since 2.0.0
  * @category execution
  */
-export declare const runCallback: <E, A>(effect: Effect<never, E, A>, options?: Runtime.RunCallbackOptions<E, A> | undefined) => Runtime.Cancel<E, A>;
+export declare const runCallback: <A, E>(effect: Effect<A, E>, options?: Runtime.RunCallbackOptions<A, E> | undefined) => Runtime.Cancel<A, E>;
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
  * result of the workflow or rejects with an error.
@@ -3460,7 +3459,7 @@ export declare const runCallback: <E, A>(effect: Effect<never, E, A>, options?:
  * @since 2.0.0
  * @category execution
  */
-export declare const runPromise: <E, A>(effect: Effect<never, E, A>) => Promise<A>;
+export declare const runPromise: <A, E>(effect: Effect<A, E>) => Promise<A>;
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
  * `Exit` value of the workflow.
@@ -3468,17 +3467,17 @@ export declare const runPromise: <E, A>(effect: Effect<never, E, A>) => Promise<
  * @since 2.0.0
  * @category execution
  */
-export declare const runPromiseExit: <E, A>(effect: Effect<never, E, A>) => Promise<Exit.Exit<E, A>>;
+export declare const runPromiseExit: <A, E>(effect: Effect<A, E>) => Promise<Exit.Exit<A, E>>;
 /**
  * @since 2.0.0
  * @category execution
  */
-export declare const runSync: <E, A>(effect: Effect<never, E, A>) => A;
+export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
 /**
  * @since 2.0.0
  * @category execution
  */
-export declare const runSyncExit: <E, A>(effect: Effect<never, E, A>) => Exit.Exit<E, A>;
+export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E>;
 /**
  * Sequentially zips the this result with the specified result. Combines both
  * `Cause`s when both effects fail.
@@ -3487,14 +3486,18 @@ export declare const runSyncExit: <E, A>(effect: Effect<never, E, A>) => Exit.Ex
  * @category zipping
  */
 export declare const validate: {
-    <R1, E1, B>(that: Effect<R1, E1, B>, options?: {
+    <B, E1, R1>(that: Effect<B, E1, R1>, options?: {
+        /**
+         * @since 2.0.0
+         * @category supervision & fibers
+         */
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, [A, B]>;
-    <R, E, A, R1, E1, B>(self: Effect<R, E, A>, that: Effect<R1, E1, B>, options?: {
+    } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, B], E1 | E, R1 | R>;
+    <A, E, R, B, E1, R1>(self: Effect<A, E, R>, that: Effect<B, E1, R1>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R1, E | E1, [A, B]>;
+    } | undefined): Effect<[A, B], E | E1, R | R1>;
 };
 /**
  * Sequentially zips this effect with the specified effect using the specified
@@ -3504,162 +3507,162 @@ export declare const validate: {
  * @category zipping
  */
 export declare const validateWith: {
-    <A, R1, E1, B, C>(that: Effect<R1, E1, B>, f: (a: A, b: B) => C, options?: {
+    <B, E1, R1, A, C>(that: Effect<B, E1, R1>, f: (a: A, b: B) => C, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, C>;
-    <R, E, A, R1, E1, B, C>(self: Effect<R, E, A>, that: Effect<R1, E1, B>, f: (a: A, b: B) => C, options?: {
+    } | undefined): <E, R>(self: Effect<A, E, R>) => Effect<C, E1 | E, R1 | R>;
+    <A, E, R, B, E1, R1, C>(self: Effect<A, E, R>, that: Effect<B, E1, R1>, f: (a: A, b: B) => C, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R1, E | E1, C>;
+    } | undefined): Effect<C, E | E1, R | R1>;
 };
 /**
  * @since 2.0.0
  * @category zipping
  */
 export declare const zip: {
-    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+    <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, [A, A2]>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+    } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R2, E | E2, [A, A2]>;
+    } | undefined): Effect<[A, A2], E | E2, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category zipping
  */
 export declare const zipLeft: {
-    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+    <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+    } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R2, E | E2, A>;
+    } | undefined): Effect<A, E | E2, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category zipping
  */
 export declare const zipRight: {
-    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+    <A2, E2, R2>(that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R2, E | E2, A2>;
+    }): Effect<A2, E2 | E, R2 | R>;
 };
 /**
  * @since 2.0.0
  * @category zipping
  */
 export declare const zipWith: {
-    <R2, E2, A2, A, B>(that: Effect<R2, E2, A2>, f: (a: A, b: A2) => B, options?: {
+    <A2, E2, R2, A, B>(that: Effect<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, B>;
-    <R, E, A, R2, E2, A2, B>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, f: (a: A, b: A2) => B, options?: {
+    }): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, B>(self: Effect<A, E, R>, that: Effect<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
         readonly batching?: boolean | "inherit" | undefined;
-    }): Effect<R | R2, E | E2, B>;
+    }): Effect<B, E2 | E, R2 | R>;
 };
 /**
  * @category combining
  * @since 2.0.0
  */
 export declare const ap: {
-    <R2, E2, A>(that: Effect<R2, E2, A>): <R, E, B>(self: Effect<R, E, (a: A) => B>) => Effect<R | R2, E | E2, B>;
-    <R, E, A, B, R2, E2>(self: Effect<R, E, (a: A) => B>, that: Effect<R2, E2, A>): Effect<R | R2, E | E2, B>;
+    <A, E2, R2>(that: Effect<A, E2, R2>): <B, R, E>(self: Effect<(a: A) => B, E, R>) => Effect<B, E | E2, R | R2>;
+    <A, B, E, R, E2, R2>(self: Effect<(a: A) => B, E, R>, that: Effect<A, E2, R2>): Effect<B, E | E2, R | R2>;
 };
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export declare const blocked: <E, A>(blockedRequests: RequestBlock, _continue: Effect<never, E, A>) => Blocked<E, A>;
+export declare const blocked: <A, E>(blockedRequests: RequestBlock, _continue: Effect<A, E>) => Blocked<A, E>;
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export declare const runRequestBlock: <R>(blockedRequests: RequestBlock) => Effect<R, never, void>;
+export declare const runRequestBlock: (blockedRequests: RequestBlock) => Effect<void>;
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export declare const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<E, A>>;
+export declare const step: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<A, E> | Blocked<A, E>, never, R>;
 /**
  * @since 2.0.0
  * @category requests & batching
  */
 export declare const request: {
-    <A extends Request.Request<any, any>, Ds extends RequestResolver<A, never> | Effect<any, any, RequestResolver<A, never>>>(request: A, dataSource: Ds): Effect<[
+    <A extends Request.Request<any, any>, Ds extends RequestResolver<A> | Effect<RequestResolver<A>, any, any>>(request: A, dataSource: Ds): Effect<Request.Request.Success<A>, Request.Request.Error<A>, [
         Ds
-    ] extends [Effect<any, any, any>] ? Effect.Context<Ds> : never, Request.Request.Error<A>, Request.Request.Success<A>>;
+    ] extends [Effect<any, any, any>] ? Effect.Context<Ds> : never>;
 };
 /**
  * @since 2.0.0
  * @category requests & batching
  */
-export declare const cacheRequestResult: <A extends Request.Request<any, any>>(request: A, result: Request.Request.Result<A>) => Effect<never, never, void>;
+export declare const cacheRequestResult: <A extends Request.Request<any, any>>(request: A, result: Request.Request.Result<A>) => Effect<void>;
 /**
  * @since 2.0.0
  * @category requests & batching
  */
 export declare const withRequestBatching: {
-    (requestBatching: boolean): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, requestBatching: boolean): Effect<R, E, A>;
+    (requestBatching: boolean): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, requestBatching: boolean): Effect<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category requests & batching
  */
 export declare const withRequestCaching: {
-    (strategy: boolean): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, strategy: boolean): Effect<R, E, A>;
+    (strategy: boolean): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, strategy: boolean): Effect<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category requests & batching
  */
 export declare const withRequestCache: {
-    (cache: Request.Cache): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, cache: Request.Cache): Effect<R, E, A>;
+    (cache: Request.Cache): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, cache: Request.Cache): Effect<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const tracer: Effect<never, never, Tracer.Tracer>;
+export declare const tracer: Effect<Tracer.Tracer>;
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const tracerWith: <R, E, A>(f: (tracer: Tracer.Tracer) => Effect<R, E, A>) => Effect<R, E, A>;
+export declare const tracerWith: <A, E, R>(f: (tracer: Tracer.Tracer) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * @since 2.0.0
  * @category tracing
  */
 export declare const withTracer: {
-    (value: Tracer.Tracer): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, value: Tracer.Tracer): Effect<R, E, A>;
+    (value: Tracer.Tracer): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, value: Tracer.Tracer): Effect<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const withTracerScoped: (value: Tracer.Tracer) => Effect<Scope.Scope, never, void>;
+export declare const withTracerScoped: (value: Tracer.Tracer) => Effect<void, never, Scope.Scope>;
 /**
  * @since 2.0.0
  * @category tracing
  */
 export declare const withTracerTiming: {
-    (enabled: boolean): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, enabled: boolean): Effect<R, E, A>;
+    (enabled: boolean): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, enabled: boolean): Effect<A, E, R>;
 };
 /**
  * Adds an annotation to each span in this effect.
@@ -3668,10 +3671,10 @@ export declare const withTracerTiming: {
  * @category tracing
  */
 export declare const annotateSpans: {
-    (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>;
+    (key: string, value: unknown): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    (values: Record<string, unknown>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
+    <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
 };
 /**
  * Adds an annotation to the current span if available
@@ -3680,29 +3683,29 @@ export declare const annotateSpans: {
  * @category tracing
  */
 export declare const annotateCurrentSpan: {
-    (key: string, value: unknown): Effect<never, never, void>;
-    (values: Record<string, unknown>): Effect<never, never, void>;
+    (key: string, value: unknown): Effect<void>;
+    (values: Record<string, unknown>): Effect<void>;
 };
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const currentSpan: Effect<never, Cause.NoSuchElementException, Tracer.Span>;
+export declare const currentSpan: Effect<Tracer.Span, Cause.NoSuchElementException>;
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const currentParentSpan: Effect<never, Cause.NoSuchElementException, Tracer.ParentSpan>;
+export declare const currentParentSpan: Effect<Tracer.ParentSpan, Cause.NoSuchElementException>;
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const spanAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>>;
+export declare const spanAnnotations: Effect<HashMap.HashMap<string, unknown>>;
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const spanLinks: Effect<never, never, Chunk.Chunk<Tracer.SpanLink>>;
+export declare const spanLinks: Effect<Chunk.Chunk<Tracer.SpanLink>>;
 /**
  * For all spans in this effect, add a link with the provided span.
  *
@@ -3710,8 +3713,8 @@ export declare const spanLinks: Effect<never, never, Chunk.Chunk<Tracer.SpanLink
  * @category tracing
  */
 export declare const linkSpans: {
-    (span: Tracer.ParentSpan, attributes?: Record<string, unknown>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan, attributes?: Record<string, unknown>): Effect<R, E, A>;
+    (span: Tracer.ParentSpan, attributes?: Record<string, unknown>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <A, E, R>(self: Effect<A, E, R>, span: Tracer.ParentSpan, attributes?: Record<string, unknown>): Effect<A, E, R>;
 };
 /**
  * Create a new span for tracing.
@@ -3725,7 +3728,7 @@ export declare const makeSpan: (name: string, options?: {
     readonly parent?: Tracer.ParentSpan | undefined;
     readonly root?: boolean | undefined;
     readonly context?: Context.Context<never> | undefined;
-}) => Effect<never, never, Tracer.Span>;
+}) => Effect<Tracer.Span>;
 /**
  * Create a new span for tracing, and automatically close it when the Scope
  * finalizes.
@@ -3742,7 +3745,7 @@ export declare const makeSpanScoped: (name: string, options?: {
     readonly parent?: Tracer.ParentSpan | undefined;
     readonly root?: boolean | undefined;
     readonly context?: Context.Context<never> | undefined;
-}) => Effect<Scope.Scope, never, Tracer.Span>;
+}) => Effect<Tracer.Span, never, Scope.Scope>;
 /**
  * Create a new span for tracing, and automatically close it when the effect
  * completes.
@@ -3754,14 +3757,14 @@ export declare const makeSpanScoped: (name: string, options?: {
  * @category tracing
  */
 export declare const useSpan: {
-    <R, E, A>(name: string, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
-    <R, E, A>(name: string, options: {
+    <A, E, R>(name: string, evaluate: (span: Tracer.Span) => Effect<A, E, R>): Effect<A, E, R>;
+    <A, E, R>(name: string, options: {
         readonly attributes?: Record<string, unknown> | undefined;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
+    }, evaluate: (span: Tracer.Span) => Effect<A, E, R>): Effect<A, E, R>;
 };
 /**
  * Wraps the effect with a new span for tracing.
@@ -3776,14 +3779,14 @@ export declare const withSpan: {
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Tracer.ParentSpan>, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, name: string, options?: {
+    } | undefined): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Effect<A, E, R>, name: string, options?: {
         readonly attributes?: Record<string, unknown> | undefined;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): Effect<Exclude<R, Tracer.ParentSpan>, E, A>;
+    } | undefined): Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * Wraps the effect with a new span for tracing.
@@ -3800,14 +3803,14 @@ export declare const withSpanScoped: {
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, name: string, options?: {
+    }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
+    <A, E, R>(self: Effect<A, E, R>, name: string, options?: {
         readonly attributes?: Record<string, unknown> | undefined;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): Effect<Scope.Scope | Exclude<R, Tracer.ParentSpan>, E, A>;
+    }): Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>;
 };
 /**
  * Adds the provided span to the current span stack.
@@ -3816,8 +3819,8 @@ export declare const withSpanScoped: {
  * @category tracing
  */
 export declare const withParentSpan: {
-    (span: Tracer.ParentSpan): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Tracer.ParentSpan>, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan): Effect<Exclude<R, Tracer.ParentSpan>, E, A>;
+    (span: Tracer.ParentSpan): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Effect<A, E, R>, span: Tracer.ParentSpan): Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * Returns an effect that errors with `NoSuchElementException` if the value is
@@ -3826,7 +3829,7 @@ export declare const withParentSpan: {
  * @since 2.0.0
  * @category optionality
  */
-export declare const fromNullable: <A>(value: A) => Effect<never, Cause.NoSuchElementException, NonNullable<A>>;
+export declare const fromNullable: <A>(value: A) => Effect<NonNullable<A>, Cause.NoSuchElementException>;
 /**
  * Wraps the success value of this effect with `Option.some`, and maps
  * `Cause.NoSuchElementException` to `Option.none`.
@@ -3834,5 +3837,5 @@ export declare const fromNullable: <A>(value: A) => Effect<never, Cause.NoSuchEl
  * @since 2.0.0
  * @category optionality
  */
-export declare const optionFromOptional: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Exclude<E, Cause.NoSuchElementException>, Option.Option<A>>;
+export declare const optionFromOptional: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementException>, R>;
 //# sourceMappingURL=Effect.d.ts.map