effect 3.8.3 → 3.8.5

package/src/Schedule.ts

@@ -147,7 +147,21 @@ export const makeWithState: <S, In, Out, R = never>(
  * @category utils
  */
 export const addDelay: {
+  /**
+   * Returns a new schedule with the given delay added to every interval defined
+   * by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out>(f: (out: Out) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule with the given delay added to every interval defined
+   * by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: (out: Out) => Duration.DurationInput): Schedule<Out, In, R>
 } = internal.addDelay
 
@@ -159,9 +173,23 @@ export const addDelay: {
  * @category utils
  */
 export const addDelayEffect: {
+  /**
+   * Returns a new schedule with the given effectfully computed delay added to
+   * every interval defined by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, R2>(
     f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
   ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule with the given effectfully computed delay added to
+   * every interval defined by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
@@ -175,9 +203,21 @@ export const addDelayEffect: {
  * @category sequencing
  */
 export const andThen: {
+  /**
+   * The same as `andThenEither`, but merges the output.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>
+  /**
+   * The same as `andThenEither`, but merges the output.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -192,9 +232,23 @@ export const andThen: {
  * @category sequencing
  */
 export const andThenEither: {
+  /**
+   * Returns a new schedule that first executes this schedule to completion, and
+   * then executes the specified schedule to completion.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <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>
+  /**
+   * Returns a new schedule that first executes this schedule to completion, and
+   * then executes the specified schedule to completion.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -208,7 +262,19 @@ export const andThenEither: {
  * @category mapping
  */
 export const as: {
+  /**
+   * Returns a new schedule that maps this schedule to a constant output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out2>(out: Out2): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
+  /**
+   * Returns a new schedule that maps this schedule to a constant output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, Out2>(self: Schedule<Out, In, R>, out: Out2): Schedule<Out2, In, R>
 } = internal.as
 
@@ -228,9 +294,23 @@ export const asVoid: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void,
  * @category utils
  */
 export const bothInOut: {
+  /**
+   * Returns a new schedule that has both the inputs and outputs of this and the
+   * specified schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>
+  /**
+   * Returns a new schedule that has both the inputs and outputs of this and the
+   * specified schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -246,7 +326,23 @@ export const bothInOut: {
  * @category utils
  */
 export const check: {
+  /**
+   * Returns a new schedule that passes each input and output of this schedule
+   * to the specified function, and then determines whether or not to continue
+   * based on the return value of the function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In, Out>(test: (input: In, output: Out) => boolean): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that passes each input and output of this schedule
+   * to the specified function, and then determines whether or not to continue
+   * based on the return value of the function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, test: (input: In, output: Out) => boolean): Schedule<Out, In, R>
 } = internal.check
 
@@ -259,9 +355,25 @@ export const check: {
  * @category utils
  */
 export const checkEffect: {
+  /**
+   * Returns a new schedule that passes each input and output of this schedule
+   * to the specified function, and then determines whether or not to continue
+   * based on the return value of the function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In, Out, R2>(
     test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
   ): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule that passes each input and output of this schedule
+   * to the specified function, and then determines whether or not to continue
+   * based on the return value of the function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
@@ -335,7 +447,25 @@ export const collectWhileEffect: <A, R>(
  * @category utils
  */
 export const compose: {
+  /**
+   * Returns the composition of this schedule and the specified schedule, by
+   * piping the output of this one into the input of the other. Effects
+   * described by this schedule will always be executed before the effects
+   * described by the second schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out2, Out, R2>(that: Schedule<Out2, Out, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | 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
+   * described by this schedule will always be executed before the effects
+   * described by the second schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, Out, R2>): Schedule<Out2, In, R | R2>
 } = internal.compose
 
@@ -347,7 +477,21 @@ export const compose: {
  * @category mapping
  */
 export const mapInput: {
+  /**
+   * Returns a new schedule that deals with a narrower class of inputs than this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <In, In2>(f: (in2: In2) => In): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R>
+  /**
+   * Returns a new schedule that deals with a narrower class of inputs than this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, In2>(self: Schedule<Out, In, R>, f: (in2: In2) => In): Schedule<Out, In2, R>
 } = internal.mapInput
 
@@ -359,9 +503,23 @@ export const mapInput: {
  * @category context
  */
 export const mapInputContext: {
+  /**
+   * Transforms the context being provided to this schedule with the
+   * specified function.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <R0, R>(
     f: (env0: Context.Context<R0>) => Context.Context<R>
   ): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>
+  /**
+   * Transforms the context being provided to this schedule with the
+   * specified function.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <Out, In, R, R0>(
     self: Schedule<Out, In, R>,
     f: (env0: Context.Context<R0>) => Context.Context<R>
@@ -376,9 +534,23 @@ export const mapInputContext: {
  * @category mapping
  */
 export const mapInputEffect: {
+  /**
+   * Returns a new schedule that deals with a narrower class of inputs than this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <In2, In, R2>(
     f: (in2: In2) => Effect.Effect<In, never, R2>
   ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>
+  /**
+   * Returns a new schedule that deals with a narrower class of inputs than this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, In2, R2>(
     self: Schedule<Out, In, R>,
     f: (in2: In2) => Effect.Effect<In, never, R2>
@@ -438,9 +610,23 @@ export const dayOfWeek: (day: number) => Schedule<number> = internal.dayOfWeek
  * @category utils
  */
 export const delayed: {
+  /**
+   * Returns a new schedule with the specified effectfully computed delay added
+   * before the start of each interval produced by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (
     f: (duration: Duration.Duration) => Duration.DurationInput
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule with the specified effectfully computed delay added
+   * before the start of each interval produced by this schedule.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(
     self: Schedule<Out, In, R>,
     f: (duration: Duration.Duration) => Duration.DurationInput
@@ -455,9 +641,23 @@ export const delayed: {
  * @category constructors
  */
 export const delayedEffect: {
+  /**
+   * Returns a new schedule with the specified effectfully computed delay added
+   * before the start of each interval produced by this schedule.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   <R2>(
     f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule with the specified effectfully computed delay added
+   * before the start of each interval produced by this schedule.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
@@ -490,9 +690,21 @@ export const delays: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Durati
  * @category mapping
  */
 export const mapBoth: {
+  /**
+   * Returns a new schedule that maps both the input and output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <In2, In, Out, Out2>(
     options: { readonly onInput: (in2: In2) => In; readonly onOutput: (out: Out) => Out2 }
   ): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R>
+  /**
+   * Returns a new schedule that maps both the input and output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, In2, Out2>(
     self: Schedule<Out, In, R>,
     options: { readonly onInput: (in2: In2) => In; readonly onOutput: (out: Out) => Out2 }
@@ -506,12 +718,24 @@ export const mapBoth: {
  * @category mapping
  */
 export const mapBothEffect: {
+  /**
+   * Returns a new schedule that maps both the input and output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <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>
+  /**
+   * Returns a new schedule that maps both the input and output.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, In2, R2, Out2, R3>(
     self: Schedule<Out, In, R>,
     options: {
@@ -549,9 +773,23 @@ export const duration: (duration: Duration.DurationInput) => Schedule<Duration.D
  * @category alternatives
  */
 export const either: {
+  /**
+   * Returns a new schedule that performs a geometric union on the intervals
+   * defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category alternatives
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  /**
+   * Returns a new schedule that performs a geometric union on the intervals
+   * defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category alternatives
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -565,10 +803,22 @@ export const either: {
  * @category alternatives
  */
 export const eitherWith: {
+  /**
+   * The same as `either` followed by `map`.
+   *
+   * @since 2.0.0
+   * @category alternatives
+   */
   <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>
+  /**
+   * The same as `either` followed by `map`.
+   *
+   * @since 2.0.0
+   * @category alternatives
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>,
@@ -596,7 +846,27 @@ export const elapsed: Schedule<Duration.Duration> = internal.elapsed
  * @category finalization
  */
 export const ensuring: {
+  /**
+   * 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
+   * guarantee the finalizer will be run. The `Schedule` may not initialize or
+   * the driver of the schedule may not run to completion. However, if the
+   * `Schedule` ever decides not to continue, then the finalizer will be run.
+   *
+   * @since 2.0.0
+   * @category finalization
+   */
   <X>(finalizer: Effect.Effect<X, never, never>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * 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
+   * guarantee the finalizer will be run. The `Schedule` may not initialize or
+   * the driver of the schedule may not run to completion. However, if the
+   * `Schedule` ever decides not to continue, then the finalizer will be run.
+   *
+   * @since 2.0.0
+   * @category finalization
+   */
   <Out, In, R, X>(self: Schedule<Out, In, R>, finalizer: Effect.Effect<X, never, never>): Schedule<Out, In, R>
 } = internal.ensuring
 
@@ -705,9 +975,23 @@ export const identity: <A>() => Schedule<A, A> = internal.identity
  * @category utils
  */
 export const intersect: {
+  /**
+   * Returns a new schedule that performs a geometric intersection on the
+   * intervals defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  /**
+   * Returns a new schedule that performs a geometric intersection on the
+   * intervals defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -723,10 +1007,26 @@ export const intersect: {
  * @category utils
  */
 export const intersectWith: {
+  /**
+   * Returns a new schedule that combines this schedule with the specified
+   * schedule, continuing as long as both schedules want to continue and merging
+   * the next intervals according to the specified merge function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <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>
+  /**
+   * Returns a new schedule that combines this schedule with the specified
+   * schedule, continuing as long as both schedules want to continue and merging
+   * the next intervals according to the specified merge function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>,
@@ -759,9 +1059,29 @@ export const jittered: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out,
  * @category constructors
  */
 export const jitteredWith: {
+  /**
+   * Returns a new schedule that randomly modifies the size of the intervals of
+   * this schedule.
+   *
+   * The new interval size is between `min * old interval size` and `max * old
+   * interval size`.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   (
     options: { min?: number | undefined; max?: number | undefined }
   ): <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.
+   *
+   * The new interval size is between `min * old interval size` and `max * old
+   * interval size`.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   <Out, In, R>(
     self: Schedule<Out, In, R>,
     options: { min?: number | undefined; max?: number | undefined }
@@ -786,7 +1106,21 @@ export const linear: (base: Duration.DurationInput) => Schedule<Duration.Duratio
  * @category mapping
  */
 export const map: {
+  /**
+   * Returns a new schedule that maps the output of this schedule through the
+   * specified function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, Out2>(f: (out: Out) => Out2): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
+  /**
+   * Returns a new schedule that maps the output of this schedule through the
+   * specified function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, Out2>(self: Schedule<Out, In, R>, f: (out: Out) => Out2): Schedule<Out2, In, R>
 } = internal.map
 
@@ -798,9 +1132,23 @@ export const map: {
  * @category mapping
  */
 export const mapEffect: {
+  /**
+   * Returns a new schedule that maps the output of this schedule through the
+   * specified effectful function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, Out2, R2>(
     f: (out: Out) => Effect.Effect<Out2, never, R2>
   ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
+  /**
+   * Returns a new schedule that maps the output of this schedule through the
+   * specified effectful function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <Out, In, R, Out2, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out) => Effect.Effect<Out2, never, R2>
@@ -827,9 +1175,23 @@ export const minuteOfHour: (minute: number) => Schedule<number> = internal.minut
  * @category utils
  */
 export const modifyDelay: {
+  /**
+   * Returns a new schedule that modifies the delay using the specified
+   * function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out>(
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
   ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that modifies the delay using the specified
+   * function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(
     self: Schedule<Out, In, R>,
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
@@ -844,9 +1206,23 @@ export const modifyDelay: {
  * @category utils
  */
 export const modifyDelayEffect: {
+  /**
+   * Returns a new schedule that modifies the delay using the specified
+   * effectual function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <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>
+  /**
+   * Returns a new schedule that modifies the delay using the specified
+   * effectual function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
@@ -862,9 +1238,25 @@ export const modifyDelayEffect: {
  * @category utils
  */
 export const onDecision: {
+  /**
+   * Returns a new schedule that applies the current one but runs the specified
+   * effect for every decision of this schedule. This can be used to create
+   * schedules that log failures, decisions, or computed values.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <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>
+  /**
+   * Returns a new schedule that applies the current one but runs the specified
+   * effect for every decision of this schedule. This can be used to create
+   * schedules that log failures, decisions, or computed values.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, X, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
@@ -895,7 +1287,21 @@ export const passthrough: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<I
  * @category context
  */
 export const provideContext: {
+  /**
+   * Returns a new schedule with its context provided to it, so the
+   * resulting schedule does not require any context.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <R>(context: Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, never>
+  /**
+   * Returns a new schedule with its context provided to it, so the
+   * resulting schedule does not require any context.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, context: Context.Context<R>): Schedule<Out, In, never>
 } = internal.provideContext
 
@@ -908,10 +1314,26 @@ export const provideContext: {
  * @category context
  */
 export const provideService: {
+  /**
+   * Returns a new schedule with the single service it requires provided to it.
+   * If the schedule requires multiple services use `provideContext`
+   * instead.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <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>>>
+  /**
+   * Returns a new schedule with the single service it requires provided to it.
+   * If the schedule requires multiple services use `provideContext`
+   * instead.
+   *
+   * @since 2.0.0
+   * @category context
+   */
   <Out, In, R, T extends Context.Tag<any, any>>(
     self: Schedule<Out, In, R>,
     tag: T,
@@ -988,7 +1410,19 @@ export const recurs: (n: number) => Schedule<number> = internal.recurs
  * @category folding
  */
 export const reduce: {
+  /**
+   * Returns a new schedule that folds over the outputs of this one.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R>
+  /**
+   * Returns a new schedule that folds over the outputs of this one.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Out, In, R, Z>(self: Schedule<Out, In, R>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Z, In, R>
 } = internal.reduce
 
@@ -999,10 +1433,22 @@ export const reduce: {
  * @category folding
  */
 export const reduceEffect: {
+  /**
+   * Returns a new schedule that effectfully folds over the outputs of this one.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <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>
+  /**
+   * Returns a new schedule that effectfully folds over the outputs of this one.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Out, In, R, Z, R2>(
     self: Schedule<Out, In, R>,
     zero: Z,
@@ -1035,7 +1481,21 @@ export const repetitions: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<n
  * @category utils
  */
 export const resetAfter: {
+  /**
+   * Return a new schedule that automatically resets the schedule to its initial
+   * state after some time of inactivity defined by `duration`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Return a new schedule that automatically resets the schedule to its initial
+   * state after some time of inactivity defined by `duration`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
 } = internal.resetAfter
 
@@ -1047,7 +1507,21 @@ export const resetAfter: {
  * @category utils
  */
 export const resetWhen: {
+  /**
+   * Resets the schedule when the specified predicate on the schedule output
+   * evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Resets the schedule when the specified predicate on the schedule output
+   * evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.resetWhen
 
@@ -1058,10 +1532,22 @@ export const resetWhen: {
  * @category destructors
  */
 export const run: {
+  /**
+   * Runs a schedule using the provided inputs, and collects all outputs.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <In>(
     now: number,
     input: Iterable<In>
   ): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>
+  /**
+   * Runs a schedule using the provided inputs, and collects all outputs.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, now: number, input: Iterable<In>): Effect.Effect<Chunk.Chunk<Out>, never, R>
 } = internal.run
 
@@ -1120,9 +1606,23 @@ export const sync: <A>(evaluate: LazyArg<A>) => Schedule<A> = internal.sync
  * @category sequencing
  */
 export const tapInput: {
+  /**
+   * Returns a new schedule that effectfully processes every input to this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <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>
+  /**
+   * Returns a new schedule that effectfully processes every input to this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <Out, In, R, In2, X, R2>(
     self: Schedule<Out, In, R>,
     f: (input: In2) => Effect.Effect<X, never, R2>
@@ -1137,9 +1637,23 @@ export const tapInput: {
  * @category sequencing
  */
 export const tapOutput: {
+  /**
+   * Returns a new schedule that effectfully processes every output from this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <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>
+  /**
+   * Returns a new schedule that effectfully processes every output from this
+   * schedule.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <Out, In, R, XO extends Out, X, R2>(
     self: Schedule<Out, In, R>,
     f: (out: XO) => Effect.Effect<X, never, R2>
@@ -1163,9 +1677,23 @@ export const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<A> = internal.u
  * @category utils
  */
 export const union: {
+  /**
+   * Returns a new schedule that performs a geometric union on the intervals
+   * defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  /**
+   * Returns a new schedule that performs a geometric union on the intervals
+   * defined by both schedules.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -1181,10 +1709,26 @@ export const union: {
  * @category utils
  */
 export const unionWith: {
+  /**
+   * Returns a new schedule that combines this schedule with the specified
+   * schedule, continuing as long as either schedule wants to continue and
+   * merging the next intervals according to the specified merge function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <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>
+  /**
+   * Returns a new schedule that combines this schedule with the specified
+   * schedule, continuing as long as either schedule wants to continue and
+   * merging the next intervals according to the specified merge function.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>,
@@ -1200,7 +1744,21 @@ export const unionWith: {
  * @category utils
  */
 export const untilInput: {
+  /**
+   * Returns a new schedule that continues until the specified predicate on the
+   * input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that continues until the specified predicate on the
+   * input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
 } = internal.untilInput
 
@@ -1212,9 +1770,23 @@ export const untilInput: {
  * @category utils
  */
 export const untilInputEffect: {
+  /**
+   * Returns a new schedule that continues until the specified effectful
+   * predicate on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In, R2>(
     f: (input: In) => Effect.Effect<boolean, never, R2>
   ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule that continues until the specified effectful
+   * predicate on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (input: In) => Effect.Effect<boolean, never, R2>
@@ -1229,7 +1801,21 @@ export const untilInputEffect: {
  * @category utils
  */
 export const untilOutput: {
+  /**
+   * Returns a new schedule that continues until the specified predicate on the
+   * output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that continues until the specified predicate on the
+   * output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.untilOutput
 
@@ -1241,9 +1827,23 @@ export const untilOutput: {
  * @category utils
  */
 export const untilOutputEffect: {
+  /**
+   * Returns a new schedule that continues until the specified effectful
+   * predicate on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, R2>(
     f: (out: Out) => Effect.Effect<boolean, never, R2>
   ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule that continues until the specified effectful
+   * predicate on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out) => Effect.Effect<boolean, never, R2>
@@ -1257,7 +1857,19 @@ export const untilOutputEffect: {
  * @category utils
  */
 export const upTo: {
+  /**
+   * A schedule that recurs during the given duration.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * A schedule that recurs during the given duration.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
 } = internal.upTo
 
@@ -1269,7 +1881,21 @@ export const upTo: {
  * @category utils
  */
 export const whileInput: {
+  /**
+   * Returns a new schedule that continues for as long as the specified predicate
+   * on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that continues for as long as the specified predicate
+   * on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
 } = internal.whileInput
 
@@ -1281,9 +1907,23 @@ export const whileInput: {
  * @category utils
  */
 export const whileInputEffect: {
+  /**
+   * Returns a new schedule that continues for as long as the specified effectful
+   * predicate on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <In, R2>(
     f: (input: In) => Effect.Effect<boolean, never, R2>
   ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule that continues for as long as the specified effectful
+   * predicate on the input evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (input: In) => Effect.Effect<boolean, never, R2>
@@ -1298,7 +1938,21 @@ export const whileInputEffect: {
  * @category utils
  */
 export const whileOutput: {
+  /**
+   * Returns a new schedule that continues for as long the specified predicate
+   * on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  /**
+   * Returns a new schedule that continues for as long the specified predicate
+   * on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.whileOutput
 
@@ -1310,9 +1964,23 @@ export const whileOutput: {
  * @category utils
  */
 export const whileOutputEffect: {
+  /**
+   * Returns a new schedule that continues for as long the specified effectful
+   * predicate on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, R2>(
     f: (out: Out) => Effect.Effect<boolean, never, R2>
   ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  /**
+   * Returns a new schedule that continues for as long the specified effectful
+   * predicate on the output evaluates to true.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <Out, In, R, R2>(
     self: Schedule<Out, In, R>,
     f: (out: Out) => Effect.Effect<boolean, never, R2>
@@ -1344,9 +2012,21 @@ export const windowed: (interval: Duration.DurationInput) => Schedule<number> =
  * @category zipping
  */
 export const zipLeft: {
+  /**
+   * The same as `intersect` but ignores the right output.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
+  /**
+   * The same as `intersect` but ignores the right output.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -1360,9 +2040,21 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
+  /**
+   * The same as `intersect` but ignores the left output.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <Out2, In2, R2>(
     that: Schedule<Out2, In2, R2>
   ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>
+  /**
+   * The same as `intersect` but ignores the left output.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <Out, In, R, Out2, In2, R2>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>
@@ -1376,10 +2068,22 @@ export const zipRight: {
  * @category zipping
  */
 export const zipWith: {
+  /**
+   * Equivalent to `intersect` followed by `map`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <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>
+  /**
+   * Equivalent to `intersect` followed by `map`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <Out, In, R, Out2, In2, R2, Out3>(
     self: Schedule<Out, In, R>,
     that: Schedule<Out2, In2, R2>,