effect 4.0.0-beta.3 → 4.0.0-beta.31

package/dist/Schedule.d.ts

@@ -31,7 +31,7 @@ declare const TypeId = "~effect/Schedule";
  * const program = Effect.gen(function*() {
  *   // Using retry schedule
  *   const result1 = yield* Effect.retry(
- *     Effect.fail("temporary error"),
+ *     Effect.suspend(() => Math.random() > 0.5 ? Effect.fail("temporary error") : Effect.succeed("Success")),
  *     retrySchedule
  *   )
  *
@@ -143,7 +143,7 @@ export declare const CurrentMetadata: ServiceMap.Reference<Metadata<unknown, unk
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 3) {
- *         yield* Effect.fail(`Attempt ${attempt} failed`)
+ *         return yield* Effect.fail(`Attempt ${attempt} failed`)
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -272,7 +272,7 @@ export declare const isSchedule: (u: unknown) => u is Schedule<unknown, never, u
  * @since 4.0.0
  * @category constructors
  */
-export declare const fromStep: <Input, Output, EnvX, Error, ErrorX, Env>(step: Effect<(now: number, input: Input) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output, EnvX>, Error, Env>) => Schedule<Output, Input, Error | ErrorX, Env | EnvX>;
+export declare const fromStep: <Input, Output, EnvX, Error, ErrorX, Env>(step: Effect<(now: number, input: Input) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output, EnvX>, Error, Env>) => Schedule<Output, Input, Error | Pull.ExcludeDone<ErrorX>, Env | EnvX>;
 /**
  * Creates a Schedule from a step function that receives metadata about the schedule's execution.
  *
@@ -297,7 +297,7 @@ export declare const fromStep: <Input, Output, EnvX, Error, ErrorX, Env>(step: E
  * @since 4.0.0
  * @category constructors
  */
-export declare const fromStepWithMetadata: <Input, Output, EnvX, ErrorX, Error, Env>(step: Effect<(options: InputMetadata<Input>) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output, EnvX>, Error, Env>) => Schedule<Output, Input, Error | ErrorX, Env | EnvX>;
+export declare const fromStepWithMetadata: <Input, Output, EnvX, ErrorX, Error, Env>(step: Effect<(options: InputMetadata<Input>) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output, EnvX>, Error, Env>) => Schedule<Output, Input, Error | Pull.ExcludeDone<ErrorX>, Env | EnvX>;
 /**
  * Extracts the step function from a Schedule.
  *
@@ -367,7 +367,9 @@ export declare const toStepWithSleep: <Output, Input, Error, Env>(schedule: Sche
  *
  * @example
  * ```ts
- * import { Console, Duration, Effect, Schedule } from "effect"
+ * import { Console, Data, Duration, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Add random jitter to schedule delays
  * const jitteredSchedule = Schedule.addDelay(
@@ -463,7 +465,7 @@ export declare const toStepWithSleep: <Output, Input, Error, Env>(schedule: Sche
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 5) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -484,7 +486,9 @@ export declare const addDelay: {
      *
      * @example
      * ```ts
-     * import { Console, Duration, Effect, Schedule } from "effect"
+     * import { Console, Data, Duration, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Add random jitter to schedule delays
      * const jitteredSchedule = Schedule.addDelay(
@@ -580,7 +584,7 @@ export declare const addDelay: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 5) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -594,14 +598,16 @@ export declare const addDelay: {
      * @since 2.0.0
      * @category utils
      */
-    <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.Input, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that adds the delay computed by the specified
      * effectful function to the the next recurrence of the schedule.
      *
      * @example
      * ```ts
-     * import { Console, Duration, Effect, Schedule } from "effect"
+     * import { Console, Data, Duration, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Add random jitter to schedule delays
      * const jitteredSchedule = Schedule.addDelay(
@@ -697,7 +703,7 @@ export declare const addDelay: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 5) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -711,7 +717,7 @@ export declare const addDelay: {
      * @since 2.0.0
      * @category utils
      */
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Duration.Input, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that will first execute the left (i.e. `self`)
@@ -720,7 +726,9 @@ export declare const addDelay: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // First retry 3 times quickly, then switch to slower retries
  * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -739,7 +747,7 @@ export declare const addDelay: {
  *       attempt++
  *       yield* Console.log(`Attempt ${attempt}`)
  *       if (attempt < 6) {
- *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -759,7 +767,9 @@ export declare const andThen: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // First retry 3 times quickly, then switch to slower retries
      * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -778,7 +788,7 @@ export declare const andThen: {
      *       attempt++
      *       yield* Console.log(`Attempt ${attempt}`)
      *       if (attempt < 6) {
-     *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -798,7 +808,9 @@ export declare const andThen: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // First retry 3 times quickly, then switch to slower retries
      * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -817,7 +829,7 @@ export declare const andThen: {
      *       attempt++
      *       yield* Console.log(`Attempt ${attempt}`)
      *       if (attempt < 6) {
-     *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -962,7 +974,9 @@ export declare const andThenResult: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Both schedules must want to continue for the combined schedule to continue
  * const timeLimit = Schedule.spaced("1 second").pipe(Schedule.take(5)) // max 5 times
@@ -1004,7 +1018,7 @@ export declare const andThenResult: {
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (attempt < 3) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -1030,7 +1044,9 @@ export declare const both: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Both schedules must want to continue for the combined schedule to continue
      * const timeLimit = Schedule.spaced("1 second").pipe(Schedule.take(5)) // max 5 times
@@ -1072,7 +1088,7 @@ export declare const both: {
      *       yield* Console.log(`Retry attempt ${attempt}`)
      *
      *       if (attempt < 3) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -1098,7 +1114,9 @@ export declare const both: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Both schedules must want to continue for the combined schedule to continue
      * const timeLimit = Schedule.spaced("1 second").pipe(Schedule.take(5)) // max 5 times
@@ -1140,7 +1158,7 @@ export declare const both: {
      *       yield* Console.log(`Retry attempt ${attempt}`)
      *
      *       if (attempt < 3) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -1485,7 +1503,9 @@ export declare const bothWith: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Compose a quick retry phase followed by slower retry phase
  * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1509,7 +1529,7 @@ export declare const bothWith: {
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 7) { // Needs both phases to succeed
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -1548,7 +1568,9 @@ export declare const compose: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Compose a quick retry phase followed by slower retry phase
      * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1572,7 +1594,7 @@ export declare const compose: {
      *       yield* Console.log(`Attempt ${attempt}`)
      *
      *       if (attempt < 7) { // Needs both phases to succeed
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -1611,7 +1633,9 @@ export declare const compose: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Compose a quick retry phase followed by slower retry phase
      * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1635,7 +1659,7 @@ export declare const compose: {
      *       yield* Console.log(`Attempt ${attempt}`)
      *
      *       if (attempt < 7) { // Needs both phases to succeed
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -1935,7 +1959,7 @@ export declare const collectWhile: {
      * @since 2.0.0
      * @category utilities
      */
-    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
+    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that recurs as long as the specified `predicate`
      * returns `true`, collecting all outputs of the schedule into an array.
@@ -2040,7 +2064,7 @@ export declare const collectWhile: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
@@ -2048,7 +2072,9 @@ export declare const collectWhile: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
  *
  * // Run every minute
  * const everyMinute = Schedule.cron("* * * * *")
@@ -2149,7 +2175,7 @@ export declare const collectWhile: {
  *       yield* Console.log("Complex scheduled task...")
  *       // Simulate occasional failures
  *       if (Math.random() < 0.3) {
- *         yield* Effect.fail(new Error("Scheduled task failed"))
+ *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
  *       }
  *       return "success"
  *     }),
@@ -2172,7 +2198,9 @@ export declare const cron: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
      *
      * // Run every minute
      * const everyMinute = Schedule.cron("* * * * *")
@@ -2273,7 +2301,7 @@ export declare const cron: {
      *       yield* Console.log("Complex scheduled task...")
      *       // Simulate occasional failures
      *       if (Math.random() < 0.3) {
-     *         yield* Effect.fail(new Error("Scheduled task failed"))
+     *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
      *       }
      *       return "success"
      *     }),
@@ -2296,7 +2324,9 @@ export declare const cron: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
      *
      * // Run every minute
      * const everyMinute = Schedule.cron("* * * * *")
@@ -2397,7 +2427,7 @@ export declare const cron: {
      *       yield* Console.log("Complex scheduled task...")
      *       // Simulate occasional failures
      *       if (Math.random() < 0.3) {
-     *         yield* Effect.fail(new Error("Scheduled task failed"))
+     *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
      *       }
      *       return "success"
      *     }),
@@ -2499,13 +2529,25 @@ export declare const cron: {
  * @category constructors
  */
 export declare const delays: <Out, In, E, R>(self: Schedule<Out, In, E, R>) => Schedule<Duration.Duration, In, E, R>;
+/**
+ * Returns a schedule that recurs once after the specified duration.
+ *
+ * The schedule outputs the configured duration for its first recurrence and
+ * then completes.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const duration: (durationInput: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * Returns a new `Schedule` that will always recur, but only during the
  * specified `duration` of time.
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Run a task for exactly 5 seconds, regardless of how many iterations
  * const fiveSecondSchedule = Schedule.during("5 seconds")
@@ -2567,7 +2609,7 @@ export declare const delays: <Out, In, E, R>(self: Schedule<Out, In, E, R>) => S
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (Math.random() < 0.8) { // 80% failure rate
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -2584,7 +2626,7 @@ export declare const delays: <Out, In, E, R>(self: Schedule<Out, In, E, R>) => S
  * @since 4.0.0
  * @category constructors
  */
-export declare const during: (duration: Duration.DurationInput) => Schedule<Duration.Duration>;
+export declare const during: (duration: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * Combines two `Schedule`s by recurring if either of the two schedules wants
  * to recur, using the minimum of the two durations between recurrences and
@@ -2592,7 +2634,9 @@ export declare const during: (duration: Duration.DurationInput) => Schedule<Dura
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Either continues as long as at least one schedule wants to continue
  * const timeBasedSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(3))
@@ -2636,7 +2680,7 @@ export declare const during: (duration: Duration.DurationInput) => Schedule<Dura
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (attempt < 6) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -2662,7 +2706,9 @@ export declare const either: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Either continues as long as at least one schedule wants to continue
      * const timeBasedSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(3))
@@ -2706,7 +2752,7 @@ export declare const either: {
      *       yield* Console.log(`Retry attempt ${attempt}`)
      *
      *       if (attempt < 6) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -2732,7 +2778,9 @@ export declare const either: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Either continues as long as at least one schedule wants to continue
      * const timeBasedSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(3))
@@ -2776,7 +2824,7 @@ export declare const either: {
      *       yield* Console.log(`Retry attempt ${attempt}`)
      *
      *       if (attempt < 6) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -3166,7 +3214,9 @@ export declare const elapsed: Schedule<Duration.Duration>;
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryFailure extends Data.TaggedError("RetryFailure")<{ readonly message: string }> {}
  *
  * // Basic exponential backoff with default factor of 2
  * const basicExponential = Schedule.exponential("100 millis")
@@ -3189,7 +3239,7 @@ export declare const elapsed: Schedule<Duration.Duration>;
  *       attempt++
  *       if (attempt < 4) {
  *         yield* Console.log(`Attempt ${attempt} failed, retrying...`)
- *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+ *         return yield* Effect.fail(new RetryFailure({ message: `Failure ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -3205,7 +3255,7 @@ export declare const elapsed: Schedule<Duration.Duration>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule<Duration.Duration>;
+export declare const exponential: (base: Duration.Input, 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
@@ -3213,7 +3263,9 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Basic fibonacci schedule starting with 100ms
  * const fibSchedule = Schedule.fibonacci("100 millis")
@@ -3229,7 +3281,7 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 5) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -3270,7 +3322,7 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  * @since 2.0.0
  * @category constructors
  */
-export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Duration.Duration>;
+export declare const fibonacci: (one: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * Returns a `Schedule` that recurs on the specified fixed `interval` and
  * outputs the number of repetitions of the schedule so far.
@@ -3333,7 +3385,7 @@ export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Durati
  * @since 2.0.0
  * @category constructors
  */
-export declare const fixed: (interval: Duration.DurationInput) => Schedule<number>;
+export declare const fixed: (interval: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that maps the output of this schedule using the
  * specified function.
@@ -3459,7 +3511,7 @@ export declare const map: {
      * @since 2.0.0
      * @category mapping
      */
-    <Output, Output2, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Output2, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output2, Input, Error | Error2, Env | Env2>;
+    <Output, Output2, Error2 = never, Env2 = never>(f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output2, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that maps the output of this schedule using the
      * specified function.
@@ -3522,7 +3574,7 @@ export declare const map: {
      * @since 2.0.0
      * @category mapping
      */
-    <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Output2, Error2, Env2>): Schedule<Output2, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>): Schedule<Output2, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that modifies the delay of the next recurrence
@@ -3589,7 +3641,7 @@ export declare const modifyDelay: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Error2 = never, Env2 = never>(f: (output: Output, delay: Duration.Duration) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Error2 = never, Env2 = never>(f: (output: Output, delay: Duration.Duration) => Effect<Duration.Input, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that modifies the delay of the next recurrence
      * of the schedule using the specified effectual function.
@@ -3622,8 +3674,17 @@ export declare const modifyDelay: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output, delay: Duration.DurationInput) => Effect<Duration.DurationInput, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output, delay: Duration.Input) => Effect<Duration.Input, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
+/**
+ * Returns a new `Schedule` that randomly adjusts each recurrence delay.
+ *
+ * Delays are jittered between `80%` and `120%` of the original delay.
+ *
+ * @since 2.0.0
+ * @category utilities
+ */
+export declare const jittered: <Output, Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error, Env>;
 /**
  * Returns a new `Schedule` that outputs the inputs of the specified schedule.
  *
@@ -3659,7 +3720,9 @@ export declare const passthrough: <Output, Input, Error, Env>(self: Schedule<Out
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Basic recurs - retry at most 3 times
  * const maxThreeAttempts = Schedule.recurs(3)
@@ -3674,7 +3737,7 @@ export declare const passthrough: <Output, Input, Error, Env>(self: Schedule<Out
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -3931,7 +3994,7 @@ export declare const reduce: {
      * @since 2.0.0
      * @category utilities
      */
-    <State, Output, Error2 = never, Env2 = never>(initial: LazyArg<State>, combine: (state: State, output: Output) => Effect<State, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<State, Input, Error | Error2, Env | Env2>;
+    <State, Output, Error2 = never, Env2 = never>(initial: LazyArg<State>, combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<State, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that combines the outputs of the provided schedule
      * using the specified effectful `combine` function and starting from the
@@ -4043,7 +4106,7 @@ export declare const reduce: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, initial: LazyArg<State>, combine: (state: State, output: Output) => Effect<State, Error2, Env2>): Schedule<State, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, initial: LazyArg<State>, combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>): Schedule<State, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a schedule that recurs continuously, each repetition spaced the
@@ -4094,7 +4157,7 @@ export declare const reduce: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const spaced: (duration: Duration.DurationInput) => Schedule<number>;
+export declare const spaced: (duration: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that allows execution of an effectful function for
  * every input to the schedule, but does not alter the inputs and outputs of
@@ -4102,12 +4165,14 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryError extends Data.TaggedError("RetryError")<{ readonly message: string }> {}
  *
  * // Log retry errors for debugging
  * const errorLoggingSchedule = Schedule.exponential("100 millis").pipe(
  *   Schedule.take(3),
- *   Schedule.tapInput((error: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     Console.log(`Retry triggered by error: ${String(error)}`)
  *   )
  * )
@@ -4119,7 +4184,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+ *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -4168,7 +4233,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  * // Conditional alerting based on input
  * const alertingSchedule = Schedule.exponential("200 millis").pipe(
  *   Schedule.take(6),
- *   Schedule.tapInput((error: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     Effect.gen(function*() {
  *       if (String(error).includes("critical")) {
  *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -4190,7 +4255,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *       const errorType = isCritical
  *         ? "critical database failure"
  *         : "temporary network issue"
- *       yield* Effect.fail(new Error(errorType))
+ *       return yield* Effect.fail(new RetryError({ message: errorType }))
  *     }),
  *     alertingSchedule
  *   ).pipe(
@@ -4203,10 +4268,10 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  * // Chain multiple input taps for different purposes
  * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
  *   Schedule.take(5),
- *   Schedule.tapInput((error: Error) =>
- *     Console.log(`Error occurred: ${error.name}`)
+ *   Schedule.tapInput((error: RetryError) =>
+ *     Console.log(`Error occurred: ${error._tag}`)
  *   ),
- *   Schedule.tapInput((error: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     String(error).length > 20
  *       ? Console.log("📝 Long error message detected")
  *       : Effect.void
@@ -4225,12 +4290,14 @@ export declare const tapInput: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryError extends Data.TaggedError("RetryError")<{ readonly message: string }> {}
      *
      * // Log retry errors for debugging
      * const errorLoggingSchedule = Schedule.exponential("100 millis").pipe(
      *   Schedule.take(3),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     Console.log(`Retry triggered by error: ${String(error)}`)
      *   )
      * )
@@ -4242,7 +4309,7 @@ export declare const tapInput: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 4) {
-     *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+     *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -4291,7 +4358,7 @@ export declare const tapInput: {
      * // Conditional alerting based on input
      * const alertingSchedule = Schedule.exponential("200 millis").pipe(
      *   Schedule.take(6),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     Effect.gen(function*() {
      *       if (String(error).includes("critical")) {
      *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -4313,7 +4380,7 @@ export declare const tapInput: {
      *       const errorType = isCritical
      *         ? "critical database failure"
      *         : "temporary network issue"
-     *       yield* Effect.fail(new Error(errorType))
+     *       return yield* Effect.fail(new RetryError({ message: errorType }))
      *     }),
      *     alertingSchedule
      *   ).pipe(
@@ -4326,10 +4393,10 @@ export declare const tapInput: {
      * // Chain multiple input taps for different purposes
      * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
      *   Schedule.take(5),
-     *   Schedule.tapInput((error: Error) =>
-     *     Console.log(`Error occurred: ${error.name}`)
+     *   Schedule.tapInput((error: RetryError) =>
+     *     Console.log(`Error occurred: ${error._tag}`)
      *   ),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     String(error).length > 20
      *       ? Console.log("📝 Long error message detected")
      *       : Effect.void
@@ -4348,12 +4415,14 @@ export declare const tapInput: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryError extends Data.TaggedError("RetryError")<{ readonly message: string }> {}
      *
      * // Log retry errors for debugging
      * const errorLoggingSchedule = Schedule.exponential("100 millis").pipe(
      *   Schedule.take(3),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     Console.log(`Retry triggered by error: ${String(error)}`)
      *   )
      * )
@@ -4365,7 +4434,7 @@ export declare const tapInput: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 4) {
-     *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+     *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -4414,7 +4483,7 @@ export declare const tapInput: {
      * // Conditional alerting based on input
      * const alertingSchedule = Schedule.exponential("200 millis").pipe(
      *   Schedule.take(6),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     Effect.gen(function*() {
      *       if (String(error).includes("critical")) {
      *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -4436,7 +4505,7 @@ export declare const tapInput: {
      *       const errorType = isCritical
      *         ? "critical database failure"
      *         : "temporary network issue"
-     *       yield* Effect.fail(new Error(errorType))
+     *       return yield* Effect.fail(new RetryError({ message: errorType }))
      *     }),
      *     alertingSchedule
      *   ).pipe(
@@ -4449,10 +4518,10 @@ export declare const tapInput: {
      * // Chain multiple input taps for different purposes
      * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
      *   Schedule.take(5),
-     *   Schedule.tapInput((error: Error) =>
-     *     Console.log(`Error occurred: ${error.name}`)
+     *   Schedule.tapInput((error: RetryError) =>
+     *     Console.log(`Error occurred: ${error._tag}`)
      *   ),
-     *   Schedule.tapInput((error: Error) =>
+     *   Schedule.tapInput((error: RetryError) =>
      *     String(error).length > 20
      *       ? Console.log("📝 Long error message detected")
      *       : Effect.void
@@ -4472,7 +4541,9 @@ export declare const tapInput: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Log schedule outputs for debugging/monitoring
  * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
@@ -4487,7 +4558,7 @@ export declare const tapInput: {
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -4556,7 +4627,9 @@ export declare const tapOutput: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Log schedule outputs for debugging/monitoring
      * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
@@ -4571,7 +4644,7 @@ export declare const tapOutput: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 4) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -4640,7 +4713,9 @@ export declare const tapOutput: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Log schedule outputs for debugging/monitoring
      * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
@@ -4655,7 +4730,7 @@ export declare const tapOutput: {
      *     Effect.gen(function*() {
      *       attempt++
      *       if (attempt < 4) {
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *       return `Success on attempt ${attempt}`
      *     }),
@@ -4725,7 +4800,9 @@ export declare const tapOutput: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Limit an infinite schedule to run only 5 times
  * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -4758,7 +4835,7 @@ export declare const tapOutput: {
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 5) { // Will fail more than 3 times
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -4804,7 +4881,9 @@ export declare const take: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Limit an infinite schedule to run only 5 times
      * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -4837,7 +4916,7 @@ export declare const take: {
      *       yield* Console.log(`Attempt ${attempt}`)
      *
      *       if (attempt < 5) { // Will fail more than 3 times
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -4883,7 +4962,9 @@ export declare const take: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Schedule } from "effect"
+     * import { Console, Data, Effect, Schedule } from "effect"
+     *
+     * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
      *
      * // Limit an infinite schedule to run only 5 times
      * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -4916,7 +4997,7 @@ export declare const take: {
      *       yield* Console.log(`Attempt ${attempt}`)
      *
      *       if (attempt < 5) { // Will fail more than 3 times
-     *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+     *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
      *       }
      *
      *       return `Success on attempt ${attempt}`
@@ -5054,8 +5135,8 @@ export declare const take: {
  */
 export declare const unfold: <State, Error = never, Env = never>(initial: State, next: (state: State) => Effect<State, Error, Env>) => Schedule<State, unknown, Error, Env>;
 declare const while_: {
-    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
 export { 
 /**
@@ -5104,7 +5185,7 @@ while_ as while };
  * @since 2.0.0
  * @category constructors
  */
-export declare const windowed: (interval: Duration.DurationInput) => Schedule<number>;
+export declare const windowed: (interval: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that will recur forever.
  *
@@ -5174,6 +5255,14 @@ identity_ as identity };
  * @category ensuring types
  */
 export declare const satisfiesInputType: <T>() => <Input extends T, Output = never, Error = never, Env = never>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error, Env>;
+/**
+ * Sets the input type of the provided schedule to a specified type, without
+ * altering the schedule's behavior.
+ *
+ * @since 2.0.0
+ * @category ensuring types
+ */
+export declare const setInputType: <T>() => <Output, Error, Env>(self: Schedule<Output, T, Error, Env>) => Schedule<Output, T, Error, Env>;
 /**
  * Ensures that the provided schedule respects a specified output type.
  *