effect 2.3.8 → 2.4.1

package/dist/dts/Schedule.d.ts

@@ -36,7 +36,7 @@ export declare const ScheduleDriverTypeId: unique symbol;
  */
 export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId;
 /**
- * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
+ * A `Schedule<Out, In, R>` defines a recurring schedule, which consumes
  * values of type `In`, and which returns values of type `Out`.
  *
  * Schedules are defined as a possibly infinite set of intervals spread out over
@@ -63,7 +63,7 @@ export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId;
  * @category model
  * @since 2.0.0
  */
-export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
+export interface Schedule<out Out, in In = unknown, out R = never> extends Schedule.Variance<Out, In, R>, Pipeable {
     /**
      * Initial State
      */
@@ -71,7 +71,7 @@ export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env
     /**
      * Schedule Step
      */
-    step(now: number, input: In, state: any): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, Env>;
+    step(now: number, input: In, state: any): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, R>;
 }
 /**
  * @since 2.0.0
@@ -81,21 +81,21 @@ export declare namespace Schedule {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out Env, in In, out Out> {
+    interface Variance<out Out, in In, out R> {
         readonly [ScheduleTypeId]: {
-            readonly _Env: Types.Covariant<Env>;
-            readonly _In: Types.Contravariant<In>;
             readonly _Out: Types.Covariant<Out>;
+            readonly _In: Types.Contravariant<In>;
+            readonly _R: Types.Covariant<R>;
         };
     }
     /**
      * @since 2.0.0
      */
-    interface DriverVariance<out Env, in In, out Out> {
+    interface DriverVariance<out Out, in In, out R> {
         readonly [ScheduleDriverTypeId]: {
-            readonly _Env: Types.Covariant<Env>;
-            readonly _In: Types.Contravariant<In>;
             readonly _Out: Types.Covariant<Out>;
+            readonly _In: Types.Contravariant<In>;
+            readonly _R: Types.Covariant<R>;
         };
     }
 }
@@ -103,11 +103,11 @@ export declare namespace Schedule {
  * @since 2.0.0
  * @category models
  */
-export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.DriverVariance<Env, In, Out> {
+export interface ScheduleDriver<out Out, in In = unknown, out R = never> extends Schedule.DriverVariance<Out, In, R> {
     readonly state: Effect.Effect<unknown>;
     readonly last: Effect.Effect<Out, Cause.NoSuchElementException>;
     readonly reset: Effect.Effect<void>;
-    next(input: In): Effect.Effect<Out, Option.Option<never>, Env>;
+    next(input: In): Effect.Effect<Out, Option.Option<never>, R>;
 }
 /**
  * Constructs a new `Schedule` with the specified `initial` state and the
@@ -116,7 +116,7 @@ export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.Driver
  * @since 2.0.0
  * @category constructors
  */
-export declare const makeWithState: <S, Env, In, Out>(initial: S, step: (now: number, input: In, state: S) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, Env>) => Schedule<Env, In, Out>;
+export declare const makeWithState: <S, In, Out, R = never>(initial: S, step: (now: number, input: In, state: S) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>) => Schedule<Out, In, R>;
 /**
  * Returns a new schedule with the given delay added to every interval defined
  * by this schedule.
@@ -125,8 +125,8 @@ export declare const makeWithState: <S, Env, In, Out>(initial: S, step: (now: nu
  * @category utils
  */
 export declare const addDelay: {
-    <Out>(f: (out: Out) => Duration.DurationInput): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: (out: Out) => Duration.DurationInput): Schedule<Env, In, Out>;
+    <Out>(f: (out: Out) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: (out: Out) => Duration.DurationInput): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule with the given effectfully computed delay added to
@@ -136,8 +136,8 @@ export declare const addDelay: {
  * @category utils
  */
 export declare const addDelayEffect: {
-    <Out, Env2>(f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <Out, R2>(f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * The same as `andThenEither`, but merges the output.
@@ -146,8 +146,8 @@ export declare const addDelayEffect: {
  * @category sequencing
  */
 export declare const andThen: {
-    <Env1, In1, Out2>(that: Schedule<Env1, In1, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In & In1, Out2 | Out>;
-    <Env, In, Out, Env1, In1, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env1, In1, Out2>): Schedule<Env | Env1, In & In1, Out | Out2>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out | Out2, In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that first executes this schedule to completion, and
@@ -157,8 +157,8 @@ export declare const andThen: {
  * @category sequencing
  */
 export declare const andThenEither: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Either.Either<Out, Out2>>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, Either.Either<Out, Out2>>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Either.Either<Out2, Out>, In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Either.Either<Out2, Out>, In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that maps this schedule to a constant output.
@@ -167,8 +167,8 @@ export declare const andThenEither: {
  * @category mapping
  */
 export declare const as: {
-    <Out2>(out: Out2): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out2>;
-    <Env, In, Out, Out2>(self: Schedule<Env, In, Out>, out: Out2): Schedule<Env, In, Out2>;
+    <Out2>(out: Out2): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>;
+    <Out, In, R, Out2>(self: Schedule<Out, In, R>, out: Out2): Schedule<Out2, In, R>;
 };
 /**
  * Returns a new schedule that maps the output of this schedule to unit.
@@ -176,7 +176,7 @@ export declare const as: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const asUnit: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, void>;
+export declare const asUnit: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R>;
 /**
  * Returns a new schedule that has both the inputs and outputs of this and the
  * specified schedule.
@@ -185,16 +185,8 @@ export declare const asUnit: <Env, In, Out>(self: Schedule<Env, In, Out>) => Sch
  * @category utils
  */
 export declare const bothInOut: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, readonly [In, In2], // readonly because contravariant
-    [
-        Out,
-        Out2
-    ]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, readonly [In, In2], // readonly because contravariant
-    [
-        Out,
-        Out2
-    ]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], readonly [In, In2], R | R2>;
 };
 /**
  * Returns a new schedule that passes each input and output of this schedule
@@ -205,8 +197,8 @@ export declare const bothInOut: {
  * @category utils
  */
 export declare const check: {
-    <In, Out>(test: (input: In, output: Out) => boolean): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, test: (input: In, output: Out) => boolean): Schedule<Env, In, Out>;
+    <In, Out>(test: (input: In, output: Out) => boolean): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, test: (input: In, output: Out) => boolean): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that passes each input and output of this schedule
@@ -217,8 +209,8 @@ export declare const check: {
  * @category utils
  */
 export declare const checkEffect: {
-    <In, Out, Env2>(test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <In, Out, R2>(test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * A schedule that recurs anywhere, collecting all inputs into a `Chunk`.
@@ -226,14 +218,14 @@ export declare const checkEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllInputs: <A>() => Schedule<never, A, Chunk.Chunk<A>>;
+export declare const collectAllInputs: <A>() => Schedule<Chunk.Chunk<A>, A>;
 /**
  * Returns a new schedule that collects the outputs of this one into a chunk.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const collectAllOutputs: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Chunk.Chunk<Out>>;
+export declare const collectAllOutputs: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Chunk.Chunk<Out>, In, R>;
 /**
  * A schedule that recurs until the condition f fails, collecting all inputs
  * into a list.
@@ -241,7 +233,7 @@ export declare const collectAllOutputs: <Env, In, Out>(self: Schedule<Env, In, O
  * @since 2.0.0
  * @category utils
  */
-export declare const collectUntil: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chunk<A>>;
+export declare const collectUntil: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A>;
 /**
  * A schedule that recurs until the effectful condition f fails, collecting
  * all inputs into a list.
@@ -249,7 +241,7 @@ export declare const collectUntil: <A>(f: Predicate<A>) => Schedule<never, A, Ch
  * @since 2.0.0
  * @category utils
  */
-export declare const collectUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, Chunk.Chunk<A>>;
+export declare const collectUntilEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<Chunk.Chunk<A>, A, R>;
 /**
  * A schedule that recurs as long as the condition f holds, collecting all
  * inputs into a list.
@@ -257,7 +249,7 @@ export declare const collectUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boo
  * @since 2.0.0
  * @category utils
  */
-export declare const collectWhile: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chunk<A>>;
+export declare const collectWhile: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A>;
 /**
  * A schedule that recurs as long as the effectful condition holds, collecting
  * all inputs into a list.
@@ -265,7 +257,7 @@ export declare const collectWhile: <A>(f: Predicate<A>) => Schedule<never, A, Ch
  * @category utils
  * @since 2.0.0
  */
-export declare const collectWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, Chunk.Chunk<A>>;
+export declare const collectWhileEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<Chunk.Chunk<A>, A, R>;
 /**
  * Returns the composition of this schedule and the specified schedule, by
  * piping the output of this one into the input of the other. Effects
@@ -276,8 +268,8 @@ export declare const collectWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boo
  * @category utils
  */
 export declare const compose: {
-    <Env2, Out, Out2>(that: Schedule<Env2, Out, Out2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out2>;
-    <Env, In, Out, Env2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, Out, Out2>): Schedule<Env | Env2, In, Out2>;
+    <Out2, Out, R2>(that: Schedule<Out2, Out, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>;
+    <Out, In, R, Out2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, Out, R2>): Schedule<Out2, In, R | R2>;
 };
 /**
  * Returns a new schedule that deals with a narrower class of inputs than this
@@ -287,8 +279,8 @@ export declare const compose: {
  * @category mapping
  */
 export declare const mapInput: {
-    <In, In2>(f: (in2: In2) => In): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In2, Out>;
-    <Env, In, Out, In2>(self: Schedule<Env, In, Out>, f: (in2: In2) => In): Schedule<Env, In2, Out>;
+    <In, In2>(f: (in2: In2) => In): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R>;
+    <Out, In, R, In2>(self: Schedule<Out, In, R>, f: (in2: In2) => In): Schedule<Out, In2, R>;
 };
 /**
  * Transforms the context being provided to this schedule with the
@@ -298,8 +290,8 @@ export declare const mapInput: {
  * @category context
  */
 export declare const mapInputContext: {
-    <Env0, Env>(f: (env0: Context.Context<Env0>) => Context.Context<Env>): <In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env0, In, Out>;
-    <Env0, Env, In, Out>(self: Schedule<Env, In, Out>, f: (env0: Context.Context<Env0>) => Context.Context<Env>): Schedule<Env0, In, Out>;
+    <R0, R>(f: (env0: Context.Context<R0>) => Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>;
+    <Out, In, R, R0>(self: Schedule<Out, In, R>, f: (env0: Context.Context<R0>) => Context.Context<R>): Schedule<Out, In, R0>;
 };
 /**
  * Returns a new schedule that deals with a narrower class of inputs than this
@@ -309,8 +301,8 @@ export declare const mapInputContext: {
  * @category mapping
  */
 export declare const mapInputEffect: {
-    <In, Env2, In2>(f: (in2: In2) => Effect.Effect<In, never, Env2>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In2, Out>;
-    <Env, In, Out, Env2, In2>(self: Schedule<Env, In, Out>, f: (in2: In2) => Effect.Effect<In, never, Env2>): Schedule<Env | Env2, In2, Out>;
+    <In2, In, R2>(f: (in2: In2) => Effect.Effect<In, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>;
+    <Out, In, R, In2, R2>(self: Schedule<Out, In, R>, f: (in2: In2) => Effect.Effect<In, never, R2>): Schedule<Out, In2, R | R2>;
 };
 /**
  * A schedule that always recurs, which counts the number of recurrences.
@@ -318,7 +310,7 @@ export declare const mapInputEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const count: Schedule<never, unknown, number>;
+export declare const count: Schedule<number>;
 /**
  * Cron schedule that recurs every `minute` that matches the schedule.
  *
@@ -329,7 +321,7 @@ export declare const count: Schedule<never, unknown, number>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const cron: (expression: string | Cron.Cron) => Schedule<never, unknown, [number, number]>;
+export declare const cron: (expression: string | Cron.Cron) => Schedule<[number, number]>;
 /**
  * Cron-like schedule that recurs every specified `day` of month. Won't recur
  * on months containing less days than specified in `day` param.
@@ -341,7 +333,7 @@ export declare const cron: (expression: string | Cron.Cron) => Schedule<never, u
  * @since 2.0.0
  * @category constructors
  */
-export declare const dayOfMonth: (day: number) => Schedule<never, unknown, number>;
+export declare const dayOfMonth: (day: number) => Schedule<number>;
 /**
  * Cron-like schedule that recurs every specified `day` of each week. It
  * triggers at zero hour of the week. Producing a count of repeats: 0, 1, 2.
@@ -352,7 +344,7 @@ export declare const dayOfMonth: (day: number) => Schedule<never, unknown, numbe
  * @since 2.0.0
  * @category constructors
  */
-export declare const dayOfWeek: (day: number) => Schedule<never, unknown, number>;
+export declare const dayOfWeek: (day: number) => Schedule<number>;
 /**
  * Returns a new schedule with the specified effectfully computed delay added
  * before the start of each interval produced by this schedule.
@@ -361,8 +353,8 @@ export declare const dayOfWeek: (day: number) => Schedule<never, unknown, number
  * @category utils
  */
 export declare const delayed: {
-    (f: (duration: Duration.Duration) => Duration.DurationInput): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: (duration: Duration.Duration) => Duration.DurationInput): Schedule<Env, In, Out>;
+    (f: (duration: Duration.Duration) => Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: (duration: Duration.Duration) => Duration.DurationInput): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule with the specified effectfully computed delay added
@@ -372,8 +364,8 @@ export declare const delayed: {
  * @category constructors
  */
 export declare const delayedEffect: {
-    <Env2>(f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <R2>(f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * Takes a schedule that produces a delay, and returns a new schedule that
@@ -382,14 +374,14 @@ export declare const delayedEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const delayedSchedule: <Env, In>(schedule: Schedule<Env, In, Duration.Duration>) => Schedule<Env, In, Duration.Duration>;
+export declare const delayedSchedule: <In, R>(schedule: Schedule<Duration.Duration, In, R>) => Schedule<Duration.Duration, In, R>;
 /**
  * Returns a new schedule that outputs the delay between each occurence.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const delays: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Duration.Duration>;
+export declare const delays: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Duration.Duration, In, R>;
 /**
  * Returns a new schedule that maps both the input and output.
  *
@@ -397,14 +389,14 @@ export declare const delays: <Env, In, Out>(self: Schedule<Env, In, Out>) => Sch
  * @category mapping
  */
 export declare const mapBoth: {
-    <In, Out, In2, Out2>(options: {
+    <In2, In, Out, Out2>(options: {
         readonly onInput: (in2: In2) => In;
         readonly onOutput: (out: Out) => Out2;
-    }): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env, In2, Out2>;
-    <Env, In, Out, In2, Out2>(self: Schedule<Env, In, Out>, options: {
+    }): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R>;
+    <Out, In, R, In2, Out2>(self: Schedule<Out, In, R>, options: {
         readonly onInput: (in2: In2) => In;
         readonly onOutput: (out: Out) => Out2;
-    }): Schedule<Env, In2, Out2>;
+    }): Schedule<Out2, In2, R>;
 };
 /**
  * Returns a new schedule that maps both the input and output.
@@ -413,14 +405,14 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapBothEffect: {
-    <In2, Env2, In, Out, Env3, Out2>(options: {
-        readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>;
-        readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>;
-    }): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env3 | Env, In2, Out2>;
-    <Env, In, Out, In2, Env2, Env3, Out2>(self: Schedule<Env, In, Out>, options: {
-        readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>;
-        readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>;
-    }): Schedule<Env | Env2 | Env3, In2, Out2>;
+    <In2, In, R2, Out, R3, Out2>(options: {
+        readonly onInput: (input: In2) => Effect.Effect<In, never, R2>;
+        readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>;
+    }): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R2 | R3 | R>;
+    <Out, In, R, In2, R2, Out2, R3>(self: Schedule<Out, In, R>, options: {
+        readonly onInput: (input: In2) => Effect.Effect<In, never, R2>;
+        readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>;
+    }): Schedule<Out2, In2, R | R2 | R3>;
 };
 /**
  * Returns a driver that can be used to step the schedule, appropriately
@@ -429,7 +421,7 @@ export declare const mapBothEffect: {
  * @since 2.0.0
  * @category getter
  */
-export declare const driver: <Env, In, Out>(self: Schedule<Env, In, Out>) => Effect.Effect<ScheduleDriver<Env, In, Out>>;
+export declare const driver: <Out, In, R>(self: Schedule<Out, In, R>) => Effect.Effect<ScheduleDriver<Out, In, R>>;
 /**
  * A schedule that can recur one time, the specified amount of time into the
  * future.
@@ -437,7 +429,7 @@ export declare const driver: <Env, In, Out>(self: Schedule<Env, In, Out>) => Eff
  * @since 2.0.0
  * @category constructors
  */
-export declare const duration: (duration: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration>;
+export declare const duration: (duration: Duration.DurationInput) => Schedule<Duration.Duration>;
 /**
  * Returns a new schedule that performs a geometric union on the intervals
  * defined by both schedules.
@@ -446,8 +438,8 @@ export declare const duration: (duration: Duration.DurationInput) => Schedule<ne
  * @category alternatives
  */
 export declare const either: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * The same as `either` followed by `map`.
@@ -456,8 +448,8 @@ export declare const either: {
  * @category alternatives
  */
 export declare const eitherWith: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * A schedule that occurs everywhere, which returns the total elapsed duration
@@ -466,7 +458,7 @@ export declare const eitherWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const elapsed: Schedule<never, unknown, Duration.Duration>;
+export declare const elapsed: Schedule<Duration.Duration>;
 /**
  * Returns a new schedule that will run the specified finalizer as soon as the
  * schedule is complete. Note that unlike `Effect.ensuring`, this method does not
@@ -478,8 +470,8 @@ export declare const elapsed: Schedule<never, unknown, Duration.Duration>;
  * @category finalization
  */
 export declare const ensuring: {
-    <X>(finalizer: Effect.Effect<X>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out, X>(self: Schedule<Env, In, Out>, finalizer: Effect.Effect<X>): Schedule<Env, In, Out>;
+    <X>(finalizer: Effect.Effect<X, never, never>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R, X>(self: Schedule<Out, In, R>, finalizer: Effect.Effect<X, never, never>): Schedule<Out, In, R>;
 };
 /**
  * A schedule that always recurs, but will wait a certain amount between
@@ -489,7 +481,7 @@ export declare const ensuring: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule<never, unknown, Duration.Duration>;
+export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule<Duration.Duration>;
 /**
  * A schedule that always recurs, increasing delays by summing the preceding
  * two delays (similar to the fibonacci sequence). Returns the current
@@ -498,7 +490,7 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  * @since 2.0.0
  * @category constructors
  */
-export declare const fibonacci: (one: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration>;
+export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Duration.Duration>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -514,21 +506,21 @@ export declare const fibonacci: (one: Duration.DurationInput) => Schedule<never,
  * @since 2.0.0
  * @category constructors
  */
-export declare const fixed: (interval: Duration.DurationInput) => Schedule<never, unknown, number>;
+export declare const fixed: (interval: Duration.DurationInput) => Schedule<number>;
 /**
  * A schedule that always recurs, producing a count of repeats: 0, 1, 2.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const forever: Schedule<never, unknown, number>;
+export declare const forever: Schedule<number>;
 /**
  * A schedule that recurs once with the specified delay.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromDelay: (delay: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration>;
+export declare const fromDelay: (delay: Duration.DurationInput) => Schedule<Duration.Duration>;
 /**
  * A schedule that recurs once for each of the specified durations, delaying
  * each time for the length of the specified duration. Returns the length of
@@ -537,7 +529,7 @@ export declare const fromDelay: (delay: Duration.DurationInput) => Schedule<neve
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromDelays: (delay: Duration.DurationInput, ...delays: Array<Duration.DurationInput>) => Schedule<never, unknown, Duration.Duration>;
+export declare const fromDelays: (delay: Duration.DurationInput, ...delays: Array<Duration.DurationInput>) => Schedule<Duration.Duration>;
 /**
  * A schedule that always recurs, mapping input values through the specified
  * function.
@@ -545,7 +537,7 @@ export declare const fromDelays: (delay: Duration.DurationInput, ...delays: Arra
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromFunction: <A, B>(f: (a: A) => B) => Schedule<never, A, B>;
+export declare const fromFunction: <A, B>(f: (a: A) => B) => Schedule<B, A>;
 /**
  * Cron-like schedule that recurs every specified `hour` of each day. It
  * triggers at zero minute of the hour. Producing a count of repeats: 0, 1, 2.
@@ -555,14 +547,14 @@ export declare const fromFunction: <A, B>(f: (a: A) => B) => Schedule<never, A,
  * @since 2.0.0
  * @category constructors
  */
-export declare const hourOfDay: (hour: number) => Schedule<never, unknown, number>;
+export declare const hourOfDay: (hour: number) => Schedule<number>;
 /**
  * A schedule that always recurs, which returns inputs as outputs.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const identity: <A>() => Schedule<never, A, A>;
+export declare const identity: <A>() => Schedule<A, A>;
 /**
  * Returns a new schedule that performs a geometric intersection on the
  * intervals defined by both schedules.
@@ -571,8 +563,8 @@ export declare const identity: <A>() => Schedule<never, A, A>;
  * @category utils
  */
 export declare const intersect: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that combines this schedule with the specified
@@ -583,8 +575,8 @@ export declare const intersect: {
  * @category utils
  */
 export declare const intersectWith: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that randomly modifies the size of the intervals of
@@ -598,7 +590,7 @@ export declare const intersectWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const jittered: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
+export declare const jittered: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
 /**
  * Returns a new schedule that randomly modifies the size of the intervals of
  * this schedule.
@@ -611,13 +603,13 @@ export declare const jittered: <Env, In, Out>(self: Schedule<Env, In, Out>) => S
  */
 export declare const jitteredWith: {
     (options: {
-        min?: number;
-        max?: number;
-    }): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, options: {
-        min?: number;
-        max?: number;
-    }): Schedule<Env, In, Out>;
+        min?: number | undefined;
+        max?: number | undefined;
+    }): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, options: {
+        min?: number | undefined;
+        max?: number | undefined;
+    }): Schedule<Out, In, R>;
 };
 /**
  * A schedule that always recurs, but will repeat on a linear time interval,
@@ -627,7 +619,7 @@ export declare const jitteredWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const linear: (base: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration>;
+export declare const linear: (base: Duration.DurationInput) => Schedule<Duration.Duration>;
 /**
  * Returns a new schedule that maps the output of this schedule through the
  * specified function.
@@ -636,8 +628,8 @@ export declare const linear: (base: Duration.DurationInput) => Schedule<never, u
  * @category mapping
  */
 export declare const map: {
-    <Out, Out2>(f: (out: Out) => Out2): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out2>;
-    <Env, In, Out, Out2>(self: Schedule<Env, In, Out>, f: (out: Out) => Out2): Schedule<Env, In, Out2>;
+    <Out, Out2>(f: (out: Out) => Out2): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>;
+    <Out, In, R, Out2>(self: Schedule<Out, In, R>, f: (out: Out) => Out2): Schedule<Out2, In, R>;
 };
 /**
  * Returns a new schedule that maps the output of this schedule through the
@@ -647,8 +639,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapEffect: {
-    <Out, Env2, Out2>(f: (out: Out) => Effect.Effect<Out2, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out2>;
-    <Env, In, Out, Env2, Out2>(self: Schedule<Env, In, Out>, f: (out: Out) => Effect.Effect<Out2, never, Env2>): Schedule<Env | Env2, In, Out2>;
+    <Out, Out2, R2>(f: (out: Out) => Effect.Effect<Out2, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>;
+    <Out, In, R, Out2, R2>(self: Schedule<Out, In, R>, f: (out: Out) => Effect.Effect<Out2, never, R2>): Schedule<Out2, In, R | R2>;
 };
 /**
  * Cron-like schedule that recurs every specified `minute` of each hour. It
@@ -660,7 +652,7 @@ export declare const mapEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const minuteOfHour: (minute: number) => Schedule<never, unknown, number>;
+export declare const minuteOfHour: (minute: number) => Schedule<number>;
 /**
  * Returns a new schedule that modifies the delay using the specified
  * function.
@@ -669,8 +661,8 @@ export declare const minuteOfHour: (minute: number) => Schedule<never, unknown,
  * @category utils
  */
 export declare const modifyDelay: {
-    <Out>(f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): Schedule<Env, In, Out>;
+    <Out>(f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that modifies the delay using the specified
@@ -680,8 +672,8 @@ export declare const modifyDelay: {
  * @category utils
  */
 export declare const modifyDelayEffect: {
-    <Out, Env2>(f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <Out, R2>(f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * Returns a new schedule that applies the current one but runs the specified
@@ -692,8 +684,8 @@ export declare const modifyDelayEffect: {
  * @category utils
  */
 export declare const onDecision: {
-    <Out, Env2, X>(f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2, X>(self: Schedule<Env, In, Out>, f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <Out, X, R2>(f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, X, R2>(self: Schedule<Out, In, R>, f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * A schedule that recurs one time.
@@ -701,14 +693,14 @@ export declare const onDecision: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const once: Schedule<never, unknown, void>;
+export declare const once: Schedule<void>;
 /**
  * Returns a new schedule that passes through the inputs of this schedule.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const passthrough: <Env, Input, Output>(self: Schedule<Env, Input, Output>) => Schedule<Env, Input, Input>;
+export declare const passthrough: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<In, In, R>;
 /**
  * Returns a new schedule with its context provided to it, so the
  * resulting schedule does not require any context.
@@ -717,8 +709,8 @@ export declare const passthrough: <Env, Input, Output>(self: Schedule<Env, Input
  * @category context
  */
 export declare const provideContext: {
-    <Env>(context: Context.Context<Env>): <In, Out>(self: Schedule<Env, In, Out>) => Schedule<never, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, context: Context.Context<Env>): Schedule<never, In, Out>;
+    <R>(context: Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, never>;
+    <Out, In, R>(self: Schedule<Out, In, R>, context: Context.Context<R>): Schedule<Out, In, never>;
 };
 /**
  * Returns a new schedule with the single service it requires provided to it.
@@ -729,8 +721,8 @@ export declare const provideContext: {
  * @category context
  */
 export declare const provideService: {
-    <T, T1 extends T>(tag: any, service: T1): <Env, In, Out>(self: Schedule<T | Env, In, Out>) => Schedule<Exclude<Env, T>, In, Out>;
-    <Env, T, In, Out, T1 extends T>(self: Schedule<Env | T, In, Out>, tag: any, service: T1): Schedule<Exclude<Env, T>, In, Out>;
+    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>;
+    <Out, In, R, T extends Context.Tag<any, any>>(self: Schedule<Out, In, R>, tag: T, service: Context.Tag.Service<T>): Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * A schedule that recurs for until the predicate evaluates to true.
@@ -738,14 +730,14 @@ export declare const provideService: {
  * @since 2.0.0
  * @category utils
  */
-export declare const recurUntil: <A>(f: Predicate<A>) => Schedule<never, A, A>;
+export declare const recurUntil: <A>(f: Predicate<A>) => Schedule<A, A>;
 /**
  * A schedule that recurs for until the predicate evaluates to true.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A>;
+export declare const recurUntilEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R>;
 /**
  * A schedule that recurs for until the input value becomes applicable to
  * partial function and then map that value with given function.
@@ -753,21 +745,21 @@ export declare const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boole
  * @since 2.0.0
  * @category utils
  */
-export declare const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedule<never, A, Option.Option<B>>;
+export declare const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedule<Option.Option<B>, A>;
 /**
  * A schedule that recurs during the given duration.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const recurUpTo: (duration: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration>;
+export declare const recurUpTo: (duration: Duration.DurationInput) => Schedule<Duration.Duration>;
 /**
  * A schedule that recurs for as long as the predicate evaluates to true.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const recurWhile: <A>(f: Predicate<A>) => Schedule<never, A, A>;
+export declare const recurWhile: <A>(f: Predicate<A>) => Schedule<A, A>;
 /**
  * A schedule that recurs for as long as the effectful predicate evaluates to
  * true.
@@ -775,7 +767,7 @@ export declare const recurWhile: <A>(f: Predicate<A>) => Schedule<never, A, A>;
  * @since 2.0.0
  * @category utils
  */
-export declare const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A>;
+export declare const recurWhileEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R>;
 /**
  * A schedule spanning all time, which can be stepped only the specified
  * number of times before it terminates.
@@ -783,7 +775,7 @@ export declare const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boole
  * @category constructors
  * @since 2.0.0
  */
-export declare const recurs: (n: number) => Schedule<never, unknown, number>;
+export declare const recurs: (n: number) => Schedule<number>;
 /**
  * Returns a new schedule that folds over the outputs of this one.
  *
@@ -791,8 +783,8 @@ export declare const recurs: (n: number) => Schedule<never, unknown, number>;
  * @category folding
  */
 export declare const reduce: {
-    <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Z>;
-    <Env, In, Out, Z>(self: Schedule<Env, In, Out>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Env, In, Z>;
+    <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R>;
+    <Out, In, R, Z>(self: Schedule<Out, In, R>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Z, In, R>;
 };
 /**
  * Returns a new schedule that effectfully folds over the outputs of this one.
@@ -801,8 +793,8 @@ export declare const reduce: {
  * @category folding
  */
 export declare const reduceEffect: {
-    <Out, Env1, Z>(zero: Z, f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Z>;
-    <Env, In, Out, Env1, Z>(self: Schedule<Env, In, Out>, zero: Z, f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>): Schedule<Env | Env1, In, Z>;
+    <Z, Out, R2>(zero: Z, f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R2 | R>;
+    <Out, In, R, Z, R2>(self: Schedule<Out, In, R>, zero: Z, f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>): Schedule<Z, In, R | R2>;
 };
 /**
  * Returns a new schedule that loops this one continuously, resetting the
@@ -811,14 +803,14 @@ export declare const reduceEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatForever: Schedule<never, unknown, number>;
+export declare const repeatForever: Schedule<number>;
 /**
  * Returns a new schedule that outputs the number of repetitions of this one.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const repetitions: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, number>;
+export declare const repetitions: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<number, In, R>;
 /**
  * Return a new schedule that automatically resets the schedule to its initial
  * state after some time of inactivity defined by `duration`.
@@ -827,8 +819,8 @@ export declare const repetitions: <Env, In, Out>(self: Schedule<Env, In, Out>) =
  * @category utils
  */
 export declare const resetAfter: {
-    (duration: Duration.DurationInput): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, duration: Duration.DurationInput): Schedule<Env, In, Out>;
+    (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>;
 };
 /**
  * Resets the schedule when the specified predicate on the schedule output
@@ -838,8 +830,8 @@ export declare const resetAfter: {
  * @category utils
  */
 export declare const resetWhen: {
-    <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>;
+    <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>;
 };
 /**
  * Runs a schedule using the provided inputs, and collects all outputs.
@@ -848,8 +840,8 @@ export declare const resetWhen: {
  * @category destructors
  */
 export declare const run: {
-    <In>(now: number, input: Iterable<In>): <Env, Out>(self: Schedule<Env, In, Out>) => Effect.Effect<Chunk.Chunk<Out>, never, Env>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, now: number, input: Iterable<In>): Effect.Effect<Chunk.Chunk<Out>, never, Env>;
+    <In>(now: number, input: Iterable<In>): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, now: number, input: Iterable<In>): Effect.Effect<Chunk.Chunk<Out>, never, R>;
 };
 /**
  * Cron-like schedule that recurs every specified `second` of each minute. It
@@ -861,7 +853,7 @@ export declare const run: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const secondOfMinute: (second: number) => Schedule<never, unknown, number>;
+export declare const secondOfMinute: (second: number) => Schedule<number>;
 /**
  * Returns a schedule that recurs continuously, each repetition spaced the
  * specified duration from the last run.
@@ -869,14 +861,14 @@ export declare const secondOfMinute: (second: number) => Schedule<never, unknown
  * @since 2.0.0
  * @category constructors
  */
-export declare const spaced: (duration: Duration.DurationInput) => Schedule<never, unknown, number>;
+export declare const spaced: (duration: Duration.DurationInput) => Schedule<number>;
 /**
  * A schedule that does not recur, it just stops.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const stop: Schedule<never, unknown, void>;
+export declare const stop: Schedule<void>;
 /**
  * Returns a schedule that repeats one time, producing the specified constant
  * value.
@@ -884,7 +876,7 @@ export declare const stop: Schedule<never, unknown, void>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <A>(value: A) => Schedule<never, unknown, A>;
+export declare const succeed: <A>(value: A) => Schedule<A>;
 /**
  * Returns a schedule that repeats one time, producing the specified constant
  * value.
@@ -892,7 +884,7 @@ export declare const succeed: <A>(value: A) => Schedule<never, unknown, A>;
  * @category constructors
  * @since 2.0.0
  */
-export declare const sync: <A>(evaluate: LazyArg<A>) => Schedule<never, unknown, A>;
+export declare const sync: <A>(evaluate: LazyArg<A>) => Schedule<A>;
 /**
  * Returns a new schedule that effectfully processes every input to this
  * schedule.
@@ -901,8 +893,8 @@ export declare const sync: <A>(evaluate: LazyArg<A>) => Schedule<never, unknown,
  * @category sequencing
  */
 export declare const tapInput: {
-    <Env2, In2, X>(f: (input: In2) => Effect.Effect<X, never, Env2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out>;
-    <Env, In, Out, Env2, In2, X>(self: Schedule<Env, In, Out>, f: (input: In2) => Effect.Effect<X, never, Env2>): Schedule<Env | Env2, In & In2, Out>;
+    <In2, X, R2>(f: (input: In2) => Effect.Effect<X, never, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>;
+    <Out, In, R, In2, X, R2>(self: Schedule<Out, In, R>, f: (input: In2) => Effect.Effect<X, never, R2>): Schedule<Out, In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that effectfully processes every output from this
@@ -912,8 +904,8 @@ export declare const tapInput: {
  * @category sequencing
  */
 export declare const tapOutput: {
-    <Out, XO extends Out, Env2, X>(f: (out: XO) => Effect.Effect<X, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, XO extends Out, Env2, X>(self: Schedule<Env, In, Out>, f: (out: XO) => Effect.Effect<X, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <XO extends Out, X, R2, Out>(f: (out: XO) => Effect.Effect<X, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, XO extends Out, X, R2>(self: Schedule<Out, In, R>, f: (out: XO) => Effect.Effect<X, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * Unfolds a schedule that repeats one time from the specified state and
@@ -922,7 +914,7 @@ export declare const tapOutput: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<never, unknown, A>;
+export declare const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<A>;
 /**
  * Returns a new schedule that performs a geometric union on the intervals
  * defined by both schedules.
@@ -931,8 +923,8 @@ export declare const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<never,
  * @category utils
  */
 export declare const union: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that combines this schedule with the specified
@@ -943,8 +935,8 @@ export declare const union: {
  * @category utils
  */
 export declare const unionWith: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<Env | Env2, In & In2, [Out, Out2]>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>;
 };
 /**
  * Returns a new schedule that continues until the specified predicate on the
@@ -954,8 +946,8 @@ export declare const unionWith: {
  * @category utils
  */
 export declare const untilInput: {
-    <In>(f: Predicate<In>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<In>): Schedule<Env, In, Out>;
+    <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that continues until the specified effectful
@@ -965,8 +957,8 @@ export declare const untilInput: {
  * @category utils
  */
 export declare const untilInputEffect: {
-    <In, Env2>(f: (input: In) => Effect.Effect<boolean, never, Env2>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (input: In) => Effect.Effect<boolean, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <In, R2>(f: (input: In) => Effect.Effect<boolean, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (input: In) => Effect.Effect<boolean, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * Returns a new schedule that continues until the specified predicate on the
@@ -976,8 +968,8 @@ export declare const untilInputEffect: {
  * @category utils
  */
 export declare const untilOutput: {
-    <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>;
+    <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that continues until the specified effectful
@@ -987,8 +979,8 @@ export declare const untilOutput: {
  * @category utils
  */
 export declare const untilOutputEffect: {
-    <Out, Env2>(f: (out: Out) => Effect.Effect<boolean, never, Env2>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (out: Out) => Effect.Effect<boolean, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <Out, R2>(f: (out: Out) => Effect.Effect<boolean, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (out: Out) => Effect.Effect<boolean, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * A schedule that recurs during the given duration.
@@ -997,8 +989,8 @@ export declare const untilOutputEffect: {
  * @category utils
  */
 export declare const upTo: {
-    (duration: Duration.DurationInput): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, duration: Duration.DurationInput): Schedule<Env, In, Out>;
+    (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that continues for as long the specified predicate
@@ -1008,8 +1000,8 @@ export declare const upTo: {
  * @category utils
  */
 export declare const whileInput: {
-    <In>(f: Predicate<In>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<In>): Schedule<Env, In, Out>;
+    <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that continues for as long the specified effectful
@@ -1019,8 +1011,8 @@ export declare const whileInput: {
  * @category utils
  */
 export declare const whileInputEffect: {
-    <In, Env2>(f: (input: In) => Effect.Effect<boolean, never, Env2>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>;
-    <Env, In, Out, Env2>(self: Schedule<Env, In, Out>, f: (input: In) => Effect.Effect<boolean, never, Env2>): Schedule<Env | Env2, In, Out>;
+    <In, R2>(f: (input: In) => Effect.Effect<boolean, never, R2>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (input: In) => Effect.Effect<boolean, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * Returns a new schedule that continues for as long the specified predicate
@@ -1030,8 +1022,8 @@ export declare const whileInputEffect: {
  * @category utils
  */
 export declare const whileOutput: {
-    <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>;
-    <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>;
+    <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>;
+    <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>;
 };
 /**
  * Returns a new schedule that continues for as long the specified effectful
@@ -1041,8 +1033,8 @@ export declare const whileOutput: {
  * @category utils
  */
 export declare const whileOutputEffect: {
-    <Out, Env1>(f: (out: Out) => Effect.Effect<boolean, never, Env1>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Out>;
-    <Env, In, Out, Env1>(self: Schedule<Env, In, Out>, f: (out: Out) => Effect.Effect<boolean, never, Env1>): Schedule<Env | Env1, In, Out>;
+    <Out, R2>(f: (out: Out) => Effect.Effect<boolean, never, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>;
+    <Out, In, R, R2>(self: Schedule<Out, In, R>, f: (out: Out) => Effect.Effect<boolean, never, R2>): Schedule<Out, In, R | R2>;
 };
 /**
  * A schedule that divides the timeline to `interval`-long windows, and sleeps
@@ -1060,7 +1052,7 @@ export declare const whileOutputEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const windowed: (interval: Duration.DurationInput) => Schedule<never, unknown, number>;
+export declare const windowed: (interval: Duration.DurationInput) => Schedule<number>;
 /**
  * The same as `intersect` but ignores the right output.
  *
@@ -1068,8 +1060,8 @@ export declare const windowed: (interval: Duration.DurationInput) => Schedule<ne
  * @category zipping
  */
 export declare const zipLeft: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, Out>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out, In & In2, R | R2>;
 };
 /**
  * The same as `intersect` but ignores the left output.
@@ -1078,8 +1070,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <Env2, In2, Out2>(that: Schedule<Env2, In2, Out2>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out2>;
-    <Env, In, Out, Env2, In2, Out2>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>): Schedule<Env | Env2, In & In2, Out2>;
+    <Out2, In2, R2>(that: Schedule<Out2, In2, R2>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>): Schedule<Out2, In & In2, R | R2>;
 };
 /**
  * Equivalent to `intersect` followed by `map`.
@@ -1088,7 +1080,7 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <Env2, In2, Out2, Out, Out3>(that: Schedule<Env2, In2, Out2>, f: (out: Out, out2: Out2) => Out3): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out3>;
-    <Env, In, Out, Env2, In2, Out2, Out3>(self: Schedule<Env, In, Out>, that: Schedule<Env2, In2, Out2>, f: (out: Out, out2: Out2) => Out3): Schedule<Env | Env2, In & In2, Out3>;
+    <Out2, In2, R2, Out, Out3>(that: Schedule<Out2, In2, R2>, f: (out: Out, out2: Out2) => Out3): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out3, In & In2, R2 | R>;
+    <Out, In, R, Out2, In2, R2, Out3>(self: Schedule<Out, In, R>, that: Schedule<Out2, In2, R2>, f: (out: Out, out2: Out2) => Out3): Schedule<Out3, In & In2, R | R2>;
 };
 //# sourceMappingURL=Schedule.d.ts.map