effect 2.0.0-next.37 → 2.0.0-next.39

package/Schedule/dist/effect-Schedule.esm.js

@@ -1,57 +1,957 @@
-import '../../dist/schedule-0d31f4cc.esm.js';
-export { b as ScheduleDriverTypeId, a as ScheduleTypeId, c as addDelay, e as addDelayEffect, g as andThen, h as andThenEither, i as as, j as asUnit, k as bothInOut, l as check, n as checkEffect, o as collectAllInputs, p as collectAllOutputs, q as collectUntil, r as collectUntilEffect, t as collectWhile, u as collectWhileEffect, v as compose, z as count, A as dayOfMonth, B as dayOfWeek, C as delayed, D as delayedEffect, E as delayedSchedule, F as delays, d as driver, I as duration, J as either, K as eitherWith, L as elapsed, M as ensuring, N as exponential, O as fibonacci, P as fixed, f as forever, Q as fromDelay, R as fromDelays, T as fromFunction, U as hourOfDay, V as identity, W as intersect, X as intersectWith, Y as jittered, Z as jitteredWith, _ as linear, m as makeWithState, $ as map, G as mapBoth, H as mapBothEffect, a0 as mapEffect, w as mapInput, x as mapInputContext, y as mapInputEffect, a1 as minuteOfHour, a2 as modifyDelay, a3 as modifyDelayEffect, a4 as onDecision, a5 as once, a6 as passthrough, a7 as provideContext, a8 as provideService, a9 as recurUntil, aa as recurUntilEffect, ab as recurUntilOption, ac as recurUpTo, ad as recurWhile, ae as recurWhileEffect, af as recurs, ag as reduce, ah as reduceEffect, ai as repeatForever, aj as repetitions, ak as resetAfter, al as resetWhen, am as run, an as secondOfMinute, s as spaced, ao as stop, ap as succeed, aq as sync, ar as tapInput, as as tapOutput, at as unfold, au as union, av as unionWith, aw as untilInput, ax as untilInputEffect, ay as untilOutput, az as untilOutputEffect, aA as upTo, aB as whileInput, aC as whileInputEffect, aD as whileOutput, aE as whileOutputEffect, aF as windowed, aG as zipLeft, aH as zipRight, aI as zipWith } from '../../dist/Schedule-da001b13.esm.js';
-import '../../dist/Chunk-98371336.esm.js';
-import '../../dist/Equal-7d4ae7e7.esm.js';
-import '../../dist/Hash-039222d1.esm.js';
-import '../../dist/Function-52fb7d21.esm.js';
-import '../../dist/GlobalValue-c5f1e8e5.esm.js';
-import '../../dist/Utils-657e8bfa.esm.js';
-import '../../dist/Predicate-52271838.esm.js';
-import '../../dist/Equivalence-e5c9cba4.esm.js';
-import '../../dist/Inspectable-bda84223.esm.js';
-import '../../dist/Option-1d073850.esm.js';
-import '../../dist/Either-be9c40b9.esm.js';
-import '../../dist/Effectable-a76b6aa1.esm.js';
-import '../../dist/Data-bad1ffeb.esm.js';
-import '../../dist/Pipeable-fe51dc02.esm.js';
-import '../../dist/Number-dc454336.esm.js';
-import '../../dist/Order-2f11aa24.esm.js';
-import '../../dist/ReadonlyArray-199ff80e.esm.js';
-import '../../dist/Either-09270bbc.esm.js';
-import '../../dist/ReadonlyArray-84c71385.esm.js';
-import '../../dist/ReadonlyRecord-c1f5d048.esm.js';
-import '../../dist/Clock-ab907687.esm.js';
-import '../../dist/defaultServices-86214de4.esm.js';
-import '../../dist/Context-48179faa.esm.js';
-import '../../dist/Context-fcee7bba.esm.js';
-import '../../dist/Duration-5e9f2327.esm.js';
-import '../../dist/core-9f5f0dc2.esm.js';
-import '../../dist/Differ-3be1df41.esm.js';
-import '../../dist/HashMap-e644e23b.esm.js';
-import '../../dist/HashSet-d051e0ea.esm.js';
-import '../../dist/Stack-765c2298.esm.js';
-import '../../dist/HashSet-dff2542b.esm.js';
-import '../../dist/FiberId-556ab9ef.esm.js';
-import '../../dist/MutableRef-cb4d2fc0.esm.js';
-import '../../dist/List-c066a506.esm.js';
-import '../../dist/RuntimeFlagsPatch-a1da6096.esm.js';
-import '../../dist/timeout-4180303d.esm.js';
-import '../../dist/configProvider-cd15d971.esm.js';
-import '../../dist/config-64a67e36.esm.js';
-import '../../dist/ConfigError-5801d561.esm.js';
-import '../../dist/configError-84c0742e.esm.js';
-import '../../dist/configSecret-793e52b4.esm.js';
-import '../../dist/pathPatch-5ac830c8.esm.js';
-import '../../dist/Ref-9a9de951.esm.js';
-import '../../dist/Random-14987953.esm.js';
-import '../../dist/ScheduleDecision-e794f66d.esm.js';
-import '../../dist/ScheduleIntervals-ef5cd7c5.esm.js';
-import '../../dist/ScheduleInterval-94e80ec4.esm.js';
-import '../../dist/core-effect-e762d50b.esm.js';
-import '../../dist/FiberRefs-a6ab4b8d.esm.js';
-import '../../dist/fiberRefs-b32de18b.esm.js';
-import '../../dist/patch-99e8591b.esm.js';
-import '../../dist/label-5cb21441.esm.js';
-import '../../dist/LogLevel-2e6b00c7.esm.js';
-import '../../dist/LogSpan-e5cf11a5.esm.js';
-import '../../dist/Tracer-b07052e2.esm.js';
+import { ScheduleTypeId as ScheduleTypeId$1, ScheduleDriverTypeId as ScheduleDriverTypeId$1, makeWithState as makeWithState$1, addDelay as addDelay$1, addDelayEffect as addDelayEffect$1, andThen as andThen$1, andThenEither as andThenEither$1, as as as$1, asUnit as asUnit$1, bothInOut as bothInOut$1, check as check$1, checkEffect as checkEffect$1, collectAllInputs as collectAllInputs$1, collectAllOutputs as collectAllOutputs$1, collectUntil as collectUntil$1, collectUntilEffect as collectUntilEffect$1, collectWhile as collectWhile$1, collectWhileEffect as collectWhileEffect$1, compose as compose$1, mapInput as mapInput$1, mapInputContext as mapInputContext$1, mapInputEffect as mapInputEffect$1, count as count$1, dayOfMonth as dayOfMonth$1, dayOfWeek as dayOfWeek$1, delayed as delayed$1, delayedEffect as delayedEffect$1, delayedSchedule as delayedSchedule$1, delays as delays$1, mapBoth as mapBoth$1, mapBothEffect as mapBothEffect$1, driver as driver$1, duration as duration$1, either as either$1, eitherWith as eitherWith$1, elapsed as elapsed$1, ensuring as ensuring$1, exponential as exponential$1, fibonacci as fibonacci$1, fixed as fixed$1, forever as forever$1, fromDelay as fromDelay$1, fromDelays as fromDelays$1, fromFunction as fromFunction$1, hourOfDay as hourOfDay$1, identity as identity$1, intersect as intersect$1, intersectWith as intersectWith$1, jittered as jittered$1, jitteredWith as jitteredWith$1, linear as linear$1, map as map$1, mapEffect as mapEffect$1, minuteOfHour as minuteOfHour$1, modifyDelay as modifyDelay$1, modifyDelayEffect as modifyDelayEffect$1, onDecision as onDecision$1, once as once$1, passthrough as passthrough$1, provideContext as provideContext$1, provideService as provideService$1, recurUntil as recurUntil$1, recurUntilEffect as recurUntilEffect$1, recurUntilOption as recurUntilOption$1, recurUpTo as recurUpTo$1, recurWhile as recurWhile$1, recurWhileEffect as recurWhileEffect$1, recurs as recurs$1, reduce as reduce$1, reduceEffect as reduceEffect$1, repetitions as repetitions$1, resetAfter as resetAfter$1, resetWhen as resetWhen$1, run as run$1, secondOfMinute as secondOfMinute$1, spaced as spaced$1, stop as stop$1, succeed as succeed$1, sync as sync$1, tapInput as tapInput$1, tapOutput as tapOutput$1, unfold as unfold$1, union as union$1, unionWith as unionWith$1, untilInput as untilInput$1, untilInputEffect as untilInputEffect$1, untilOutput as untilOutput$1, untilOutputEffect as untilOutputEffect$1, upTo as upTo$1, whileInput as whileInput$1, whileInputEffect as whileInputEffect$1, whileOutput as whileOutput$1, whileOutputEffect as whileOutputEffect$1, windowed as windowed$1, zipLeft as zipLeft$1, zipRight as zipRight$1, zipWith as zipWith$1 } from '../../internal/schedule.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ScheduleTypeId = ScheduleTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ScheduleDriverTypeId = ScheduleDriverTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Schedule<Env, In, Out>` 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
+ * time. Each interval defines a window in which recurrence is possible.
+ *
+ * When schedules are used to repeat or retry effects, the starting boundary of
+ * each interval produced by a schedule is used as the moment when the effect
+ * will be executed again.
+ *
+ * Schedules compose in the following primary ways:
+ *
+ * - Union: performs the union of the intervals of two schedules
+ * - Intersection: performs the intersection of the intervals of two schedules
+ * - Sequence: concatenates the intervals of one schedule onto another
+ *
+ * In addition, schedule inputs and outputs can be transformed, filtered (to
+ * terminate a schedule early in response to some input or output), and so
+ * forth.
+ *
+ * A variety of other operators exist for transforming and combining schedules,
+ * and the companion object for `Schedule` contains all common types of
+ * schedules, both for performing retrying, as well as performing repetition.
+ *
+ * @category model
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Constructs a new `Schedule` with the specified `initial` state and the
+ * specified `step` function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeWithState = makeWithState$1;
+
+/**
+ * Returns a new schedule with the given delay added to every interval defined
+ * by this schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const addDelay = addDelay$1;
+
+/**
+ * Returns a new schedule with the given effectfully computed delay added to
+ * every interval defined by this schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const addDelayEffect = addDelayEffect$1;
+
+/**
+ * The same as `andThenEither`, but merges the output.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const andThen = andThen$1;
+
+/**
+ * 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
+ */
+const andThenEither = andThenEither$1;
+
+/**
+ * Returns a new schedule that maps this schedule to a constant output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = as$1;
+
+/**
+ * Returns a new schedule that maps the output of this schedule to unit.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asUnit = asUnit$1;
+
+/**
+ * Returns a new schedule that has both the inputs and outputs of this and the
+ * specified schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const bothInOut = bothInOut$1;
+
+/**
+ * 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
+ */
+const check = check$1;
+
+/**
+ * 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
+ */
+const checkEffect = checkEffect$1;
+
+/**
+ * A schedule that recurs anywhere, collecting all inputs into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllInputs = collectAllInputs$1;
+
+/**
+ * Returns a new schedule that collects the outputs of this one into a chunk.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectAllOutputs = collectAllOutputs$1;
+
+/**
+ * A schedule that recurs until the condition f fails, collecting all inputs
+ * into a list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectUntil = collectUntil$1;
+
+/**
+ * A schedule that recurs until the effectful condition f fails, collecting
+ * all inputs into a list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectUntilEffect = collectUntilEffect$1;
+
+/**
+ * A schedule that recurs as long as the condition f holds, collecting all
+ * inputs into a list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectWhile = collectWhile$1;
+
+/**
+ * A schedule that recurs as long as the effectful condition holds, collecting
+ * all inputs into a list.
+ *
+ * @category utils
+ * @since 2.0.0
+ */
+const collectWhileEffect = collectWhileEffect$1;
+
+/**
+ * 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
+ */
+const compose = compose$1;
+
+/**
+ * Returns a new schedule that deals with a narrower class of inputs than this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInput = mapInput$1;
+
+/**
+ * Transforms the context being provided to this schedule with the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = mapInputContext$1;
+
+/**
+ * Returns a new schedule that deals with a narrower class of inputs than this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputEffect = mapInputEffect$1;
+
+/**
+ * A schedule that always recurs, which counts the number of recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const count = count$1;
+
+/**
+ * Cron-like schedule that recurs every specified `day` of month. Won't recur
+ * on months containing less days than specified in `day` param.
+ *
+ * It triggers at zero hour of the day. Producing a count of repeats: 0, 1, 2.
+ *
+ * NOTE: `day` parameter is validated lazily. Must be in range 1...31.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dayOfMonth = dayOfMonth$1;
+
+/**
+ * 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.
+ *
+ * NOTE: `day` parameter is validated lazily. Must be in range 1 (Monday)...7
+ * (Sunday).
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dayOfWeek = dayOfWeek$1;
+
+/**
+ * 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
+ */
+const delayed = delayed$1;
+
+/**
+ * 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
+ */
+const delayedEffect = delayedEffect$1;
+
+/**
+ * Takes a schedule that produces a delay, and returns a new schedule that
+ * uses this delay to further delay intervals in the resulting schedule.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const delayedSchedule = delayedSchedule$1;
+
+/**
+ * Returns a new schedule that outputs the delay between each occurence.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const delays = delays$1;
+
+/**
+ * Returns a new schedule that maps both the input and output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBoth = mapBoth$1;
+
+/**
+ * Returns a new schedule that maps both the input and output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBothEffect = mapBothEffect$1;
+
+/**
+ * Returns a driver that can be used to step the schedule, appropriately
+ * handling sleeping.
+ *
+ * @since 2.0.0
+ * @category getter
+ */
+const driver = driver$1;
+
+/**
+ * A schedule that can recur one time, the specified amount of time into the
+ * future.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const duration = duration$1;
+
+/**
+ * Returns a new schedule that performs a geometric union on the intervals
+ * defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const either = either$1;
+
+/**
+ * The same as `either` followed by `map`.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const eitherWith = eitherWith$1;
+
+/**
+ * A schedule that occurs everywhere, which returns the total elapsed duration
+ * since the first step.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const elapsed = elapsed$1;
+
+/**
+ * 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
+ */
+const ensuring = ensuring$1;
+
+/**
+ * A schedule that always recurs, but will wait a certain amount between
+ * repetitions, given by `base * factor.pow(n)`, where `n` is the number of
+ * repetitions so far. Returns the current duration between recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const exponential = exponential$1;
+
+/**
+ * A schedule that always recurs, increasing delays by summing the preceding
+ * two delays (similar to the fibonacci sequence). Returns the current
+ * duration between recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fibonacci = fibonacci$1;
+
+/**
+ * A schedule that recurs on a fixed interval. Returns the number of
+ * repetitions of the schedule so far.
+ *
+ * If the action run between updates takes longer than the interval, then the
+ * action will be run immediately, but re-runs will not "pile up".
+ *
+ * ```
+ * |-----interval-----|-----interval-----|-----interval-----|
+ * |---------action--------||action|-----|action|-----------|
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fixed = fixed$1;
+
+/**
+ * A schedule that always recurs, producing a count of repeats: 0, 1, 2.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forever = forever$1;
+
+/**
+ * A schedule that recurs once with the specified delay.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromDelay = fromDelay$1;
+
+/**
+ * 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
+ * the current duration between recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromDelays = fromDelays$1;
+
+/**
+ * A schedule that always recurs, mapping input values through the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromFunction = fromFunction$1;
+
+/**
+ * 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.
+ *
+ * NOTE: `hour` parameter is validated lazily. Must be in range 0...23.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hourOfDay = hourOfDay$1;
+
+/**
+ * A schedule that always recurs, which returns inputs as outputs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const identity = identity$1;
+
+/**
+ * Returns a new schedule that performs a geometric intersection on the
+ * intervals defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersect = intersect$1;
+
+/**
+ * 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
+ */
+const intersectWith = intersectWith$1;
+
+/**
+ * Returns a new schedule that randomly modifies the size of the intervals of
+ * this schedule.
+ *
+ * Defaults `min` to `0.8` and `max` to `1.2`.
+ *
+ * The new interval size is between `min * old interval size` and `max * old
+ * interval size`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const jittered = jittered$1;
+
+/**
+ * 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
+ */
+const jitteredWith = jitteredWith$1;
+
+/**
+ * A schedule that always recurs, but will repeat on a linear time interval,
+ * given by `base * n` where `n` is the number of repetitions so far. Returns
+ * the current duration between recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const linear = linear$1;
+
+/**
+ * Returns a new schedule that maps the output of this schedule through the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Returns a new schedule that maps the output of this schedule through the
+ * specified effectful function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = mapEffect$1;
+
+/**
+ * Cron-like schedule that recurs every specified `minute` of each hour. It
+ * triggers at zero second of the minute. Producing a count of repeats: 0, 1,
+ * 2.
+ *
+ * NOTE: `minute` parameter is validated lazily. Must be in range 0...59.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const minuteOfHour = minuteOfHour$1;
+
+/**
+ * Returns a new schedule that modifies the delay using the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const modifyDelay = modifyDelay$1;
+
+/**
+ * Returns a new schedule that modifies the delay using the specified
+ * effectual function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const modifyDelayEffect = modifyDelayEffect$1;
+
+/**
+ * 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
+ */
+const onDecision = onDecision$1;
+
+/**
+ * A schedule that recurs one time.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const once = once$1;
+
+/**
+ * Returns a new schedule that passes through the inputs of this schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const passthrough = passthrough$1;
+
+/**
+ * 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
+ */
+const provideContext = provideContext$1;
+
+/**
+ * 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
+ */
+const provideService = provideService$1;
+
+/**
+ * A schedule that recurs for until the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUntil = recurUntil$1;
+
+/**
+ * A schedule that recurs for until the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUntilEffect = recurUntilEffect$1;
+
+/**
+ * A schedule that recurs for until the input value becomes applicable to
+ * partial function and then map that value with given function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUntilOption = recurUntilOption$1;
+
+/**
+ * A schedule that recurs during the given duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUpTo = recurUpTo$1;
+
+/**
+ * A schedule that recurs for as long as the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurWhile = recurWhile$1;
+
+/**
+ * A schedule that recurs for as long as the effectful predicate evaluates to
+ * true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurWhileEffect = recurWhileEffect$1;
+
+/**
+ * A schedule spanning all time, which can be stepped only the specified
+ * number of times before it terminates.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const recurs = recurs$1;
+
+/**
+ * Returns a new schedule that folds over the outputs of this one.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce = reduce$1;
+
+/**
+ * Returns a new schedule that effectfully folds over the outputs of this one.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduceEffect = reduceEffect$1;
+
+/**
+ * Returns a new schedule that loops this one continuously, resetting the
+ * state when this schedule is done.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatForever = forever$1;
+
+/**
+ * Returns a new schedule that outputs the number of repetitions of this one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repetitions = repetitions$1;
+
+/**
+ * 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
+ */
+const resetAfter = resetAfter$1;
+
+/**
+ * Resets the schedule when the specified predicate on the schedule output
+ * evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const resetWhen = resetWhen$1;
+
+/**
+ * Runs a schedule using the provided inputs, and collects all outputs.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = run$1;
+
+/**
+ * Cron-like schedule that recurs every specified `second` of each minute. It
+ * triggers at zero nanosecond of the second. Producing a count of repeats: 0,
+ * 1, 2.
+ *
+ * NOTE: `second` parameter is validated lazily. Must be in range 0...59.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const secondOfMinute = secondOfMinute$1;
+
+/**
+ * Returns a schedule that recurs continuously, each repetition spaced the
+ * specified duration from the last run.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const spaced = spaced$1;
+
+/**
+ * A schedule that does not recur, it just stops.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const stop = stop$1;
+
+/**
+ * Returns a schedule that repeats one time, producing the specified constant
+ * value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Returns a schedule that repeats one time, producing the specified constant
+ * value.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const sync = sync$1;
+
+/**
+ * Returns a new schedule that effectfully processes every input to this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapInput = tapInput$1;
+
+/**
+ * Returns a new schedule that effectfully processes every output from this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapOutput = tapOutput$1;
+
+/**
+ * Unfolds a schedule that repeats one time from the specified state and
+ * iterator.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfold = unfold$1;
+
+/**
+ * Returns a new schedule that performs a geometric union on the intervals
+ * defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const union = union$1;
+
+/**
+ * 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
+ */
+const unionWith = unionWith$1;
+
+/**
+ * Returns a new schedule that continues until the specified predicate on the
+ * input evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilInput = untilInput$1;
+
+/**
+ * Returns a new schedule that continues until the specified effectful
+ * predicate on the input evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilInputEffect = untilInputEffect$1;
+
+/**
+ * Returns a new schedule that continues until the specified predicate on the
+ * output evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilOutput = untilOutput$1;
+
+/**
+ * Returns a new schedule that continues until the specified effectful
+ * predicate on the output evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilOutputEffect = untilOutputEffect$1;
+
+/**
+ * A schedule that recurs during the given duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const upTo = upTo$1;
+
+/**
+ * Returns a new schedule that continues for as long the specified predicate
+ * on the input evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whileInput = whileInput$1;
+
+/**
+ * Returns a new schedule that continues for as long the specified effectful
+ * predicate on the input evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whileInputEffect = whileInputEffect$1;
+
+/**
+ * Returns a new schedule that continues for as long the specified predicate
+ * on the output evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whileOutput = whileOutput$1;
+
+/**
+ * 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
+ */
+const whileOutputEffect = whileOutputEffect$1;
+
+/**
+ * A schedule that divides the timeline to `interval`-long windows, and sleeps
+ * until the nearest window boundary every time it recurs.
+ *
+ * For example, `windowed(Duration.seconds(10))` would produce a schedule as
+ * follows:
+ *
+ * ```
+ *      10s        10s        10s       10s
+ * |----------|----------|----------|----------|
+ * |action------|sleep---|act|-sleep|action----|
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const windowed = windowed$1;
+
+/**
+ * The same as `intersect` but ignores the right output.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeft$1;
+
+/**
+ * The same as `intersect` but ignores the left output.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = zipRight$1;
+
+/**
+ * Equivalent to `intersect` followed by `map`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = zipWith$1;
+
+export { ScheduleDriverTypeId, ScheduleTypeId, addDelay, addDelayEffect, andThen, andThenEither, as, asUnit, bothInOut, check, checkEffect, collectAllInputs, collectAllOutputs, collectUntil, collectUntilEffect, collectWhile, collectWhileEffect, compose, count, dayOfMonth, dayOfWeek, delayed, delayedEffect, delayedSchedule, delays, driver, duration, either, eitherWith, elapsed, ensuring, exponential, fibonacci, fixed, forever, fromDelay, fromDelays, fromFunction, hourOfDay, identity, intersect, intersectWith, jittered, jitteredWith, linear, makeWithState, map, mapBoth, mapBothEffect, mapEffect, mapInput, mapInputContext, mapInputEffect, minuteOfHour, modifyDelay, modifyDelayEffect, onDecision, once, passthrough, provideContext, provideService, recurUntil, recurUntilEffect, recurUntilOption, recurUpTo, recurWhile, recurWhileEffect, recurs, reduce, reduceEffect, repeatForever, repetitions, resetAfter, resetWhen, run, secondOfMinute, spaced, stop, succeed, sync, tapInput, tapOutput, unfold, union, unionWith, untilInput, untilInputEffect, untilOutput, untilOutputEffect, upTo, whileInput, whileInputEffect, whileOutput, whileOutputEffect, windowed, zipLeft, zipRight, zipWith };