effect 2.0.0-next.42 → 2.0.0-next.44

package/Schedule/dist/effect-Schedule.cjs.prod.js

@@ -2,161 +2,1112 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/schedule-eb6e347d.cjs.prod.js');
-var Schedule_dist_effectSchedule = require('../../dist/Schedule-2ed66272.cjs.prod.js');
-require('../../dist/Chunk-6cf5a8e6.cjs.prod.js');
-require('../../dist/Equal-ce9977a8.cjs.prod.js');
-require('../../dist/Hash-1bd73210.cjs.prod.js');
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-require('../../dist/GlobalValue-cb645c99.cjs.prod.js');
-require('../../dist/Utils-864e1d48.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Inspectable-3c4a0f5d.cjs.prod.js');
-require('../../dist/Option-02025c86.cjs.prod.js');
-require('../../dist/Either-d03d5f05.cjs.prod.js');
-require('../../dist/Effectable-f867d1cb.cjs.prod.js');
-require('../../dist/Data-07dc27f1.cjs.prod.js');
-require('../../dist/Pipeable-d3ec6711.cjs.prod.js');
-require('../../dist/Number-cb2ba2e8.cjs.prod.js');
-require('../../dist/Order-8a112bfb.cjs.prod.js');
-require('../../dist/ReadonlyArray-8157f697.cjs.prod.js');
-require('../../dist/Either-3fab3796.cjs.prod.js');
+var schedule = require('../../dist/schedule-1d92198c.cjs.prod.js');
+require('../../Chunk/dist/effect-Chunk.cjs.prod.js');
+require('../../Equal/dist/effect-Equal.cjs.prod.js');
+require('../../Hash/dist/effect-Hash.cjs.prod.js');
+require('../../Function/dist/effect-Function.cjs.prod.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
+require('../../Utils/dist/effect-Utils.cjs.prod.js');
+require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.prod.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.prod.js');
+require('../../Option/dist/effect-Option.cjs.prod.js');
+require('../../dist/Either-7a881c7a.cjs.prod.js');
+require('../../dist/Effectable-cd8f3a96.cjs.prod.js');
+require('../../Data/dist/effect-Data.cjs.prod.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.prod.js');
+require('../../Number/dist/effect-Number.cjs.prod.js');
+require('../../Order/dist/effect-Order.cjs.prod.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
+require('../../Either/dist/effect-Either.cjs.prod.js');
 require('../../dist/ReadonlyArray-f9ed7a05.cjs.prod.js');
-require('../../dist/ReadonlyRecord-8db8bada.cjs.prod.js');
-require('../../dist/Clock-fb3f7535.cjs.prod.js');
-require('../../dist/defaultServices-85cd09a5.cjs.prod.js');
-require('../../dist/Context-25a49952.cjs.prod.js');
-require('../../dist/Context-f958cabc.cjs.prod.js');
-require('../../dist/Duration-0bc08d03.cjs.prod.js');
-require('../../dist/core-99a7f5f2.cjs.prod.js');
-require('../../dist/Differ-0bd34066.cjs.prod.js');
-require('../../dist/HashMap-12668911.cjs.prod.js');
-require('../../dist/HashSet-6fe62df2.cjs.prod.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.prod.js');
+require('../../Clock/dist/effect-Clock.cjs.prod.js');
+require('../../dist/defaultServices-086b8ac9.cjs.prod.js');
+require('../../Context/dist/effect-Context.cjs.prod.js');
+require('../../dist/Context-01a123ac.cjs.prod.js');
+require('../../Duration/dist/effect-Duration.cjs.prod.js');
+require('../../dist/core-0b0539de.cjs.prod.js');
+require('../../Differ/dist/effect-Differ.cjs.prod.js');
+require('../../HashMap/dist/effect-HashMap.cjs.prod.js');
+require('../../dist/HashSet-6257b66d.cjs.prod.js');
 require('../../dist/Stack-fc8f9fe5.cjs.prod.js');
-require('../../dist/HashSet-c40a52b1.cjs.prod.js');
-require('../../dist/FiberId-b79e8047.cjs.prod.js');
-require('../../dist/MutableRef-4a2f1f23.cjs.prod.js');
-require('../../dist/List-d9775087.cjs.prod.js');
-require('../../dist/RuntimeFlagsPatch-5570758d.cjs.prod.js');
+require('../../HashSet/dist/effect-HashSet.cjs.prod.js');
+require('../../dist/FiberId-e594f6e8.cjs.prod.js');
+require('../../MutableRef/dist/effect-MutableRef.cjs.prod.js');
+require('../../List/dist/effect-List.cjs.prod.js');
+require('../../dist/RuntimeFlagsPatch-e2769b87.cjs.prod.js');
 require('../../dist/timeout-489f3f86.cjs.prod.js');
-require('../../dist/configProvider-91019e0c.cjs.prod.js');
-require('../../dist/config-e86d2f2c.cjs.prod.js');
-require('../../dist/ConfigError-cee682fa.cjs.prod.js');
-require('../../dist/configError-6a3652f8.cjs.prod.js');
-require('../../dist/configSecret-ecb6c5b3.cjs.prod.js');
-require('../../dist/pathPatch-ded405f6.cjs.prod.js');
-require('../../dist/Ref-b0f07131.cjs.prod.js');
-require('../../dist/Random-0645cf02.cjs.prod.js');
-require('../../dist/ScheduleDecision-369f2d2b.cjs.prod.js');
-require('../../dist/ScheduleIntervals-db13140c.cjs.prod.js');
-require('../../dist/ScheduleInterval-78037484.cjs.prod.js');
-require('../../dist/core-effect-0efbe120.cjs.prod.js');
-require('../../dist/FiberRefs-802c55f6.cjs.prod.js');
-require('../../dist/fiberRefs-56d69854.cjs.prod.js');
-require('../../dist/patch-49a74eb1.cjs.prod.js');
-require('../../dist/label-3e143765.cjs.prod.js');
-require('../../dist/LogLevel-83df6f42.cjs.prod.js');
-require('../../dist/LogSpan-c905a192.cjs.prod.js');
-require('../../dist/Tracer-64cf6419.cjs.prod.js');
-
-
-
-exports.ScheduleDriverTypeId = Schedule_dist_effectSchedule.ScheduleDriverTypeId;
-exports.ScheduleTypeId = Schedule_dist_effectSchedule.ScheduleTypeId;
-exports.addDelay = Schedule_dist_effectSchedule.addDelay;
-exports.addDelayEffect = Schedule_dist_effectSchedule.addDelayEffect;
-exports.andThen = Schedule_dist_effectSchedule.andThen;
-exports.andThenEither = Schedule_dist_effectSchedule.andThenEither;
-exports.as = Schedule_dist_effectSchedule.as;
-exports.asUnit = Schedule_dist_effectSchedule.asUnit;
-exports.bothInOut = Schedule_dist_effectSchedule.bothInOut;
-exports.check = Schedule_dist_effectSchedule.check;
-exports.checkEffect = Schedule_dist_effectSchedule.checkEffect;
-exports.collectAllInputs = Schedule_dist_effectSchedule.collectAllInputs;
-exports.collectAllOutputs = Schedule_dist_effectSchedule.collectAllOutputs;
-exports.collectUntil = Schedule_dist_effectSchedule.collectUntil;
-exports.collectUntilEffect = Schedule_dist_effectSchedule.collectUntilEffect;
-exports.collectWhile = Schedule_dist_effectSchedule.collectWhile;
-exports.collectWhileEffect = Schedule_dist_effectSchedule.collectWhileEffect;
-exports.compose = Schedule_dist_effectSchedule.compose;
-exports.count = Schedule_dist_effectSchedule.count;
-exports.dayOfMonth = Schedule_dist_effectSchedule.dayOfMonth;
-exports.dayOfWeek = Schedule_dist_effectSchedule.dayOfWeek;
-exports.delayed = Schedule_dist_effectSchedule.delayed;
-exports.delayedEffect = Schedule_dist_effectSchedule.delayedEffect;
-exports.delayedSchedule = Schedule_dist_effectSchedule.delayedSchedule;
-exports.delays = Schedule_dist_effectSchedule.delays;
-exports.driver = Schedule_dist_effectSchedule.driver;
-exports.duration = Schedule_dist_effectSchedule.duration;
-exports.either = Schedule_dist_effectSchedule.either;
-exports.eitherWith = Schedule_dist_effectSchedule.eitherWith;
-exports.elapsed = Schedule_dist_effectSchedule.elapsed;
-exports.ensuring = Schedule_dist_effectSchedule.ensuring;
-exports.exponential = Schedule_dist_effectSchedule.exponential;
-exports.fibonacci = Schedule_dist_effectSchedule.fibonacci;
-exports.fixed = Schedule_dist_effectSchedule.fixed;
-exports.forever = Schedule_dist_effectSchedule.forever;
-exports.fromDelay = Schedule_dist_effectSchedule.fromDelay;
-exports.fromDelays = Schedule_dist_effectSchedule.fromDelays;
-exports.fromFunction = Schedule_dist_effectSchedule.fromFunction;
-exports.hourOfDay = Schedule_dist_effectSchedule.hourOfDay;
-exports.identity = Schedule_dist_effectSchedule.identity;
-exports.intersect = Schedule_dist_effectSchedule.intersect;
-exports.intersectWith = Schedule_dist_effectSchedule.intersectWith;
-exports.jittered = Schedule_dist_effectSchedule.jittered;
-exports.jitteredWith = Schedule_dist_effectSchedule.jitteredWith;
-exports.linear = Schedule_dist_effectSchedule.linear;
-exports.makeWithState = Schedule_dist_effectSchedule.makeWithState;
-exports.map = Schedule_dist_effectSchedule.map;
-exports.mapBoth = Schedule_dist_effectSchedule.mapBoth;
-exports.mapBothEffect = Schedule_dist_effectSchedule.mapBothEffect;
-exports.mapEffect = Schedule_dist_effectSchedule.mapEffect;
-exports.mapInput = Schedule_dist_effectSchedule.mapInput;
-exports.mapInputContext = Schedule_dist_effectSchedule.mapInputContext;
-exports.mapInputEffect = Schedule_dist_effectSchedule.mapInputEffect;
-exports.minuteOfHour = Schedule_dist_effectSchedule.minuteOfHour;
-exports.modifyDelay = Schedule_dist_effectSchedule.modifyDelay;
-exports.modifyDelayEffect = Schedule_dist_effectSchedule.modifyDelayEffect;
-exports.onDecision = Schedule_dist_effectSchedule.onDecision;
-exports.once = Schedule_dist_effectSchedule.once;
-exports.passthrough = Schedule_dist_effectSchedule.passthrough;
-exports.provideContext = Schedule_dist_effectSchedule.provideContext;
-exports.provideService = Schedule_dist_effectSchedule.provideService;
-exports.recurUntil = Schedule_dist_effectSchedule.recurUntil;
-exports.recurUntilEffect = Schedule_dist_effectSchedule.recurUntilEffect;
-exports.recurUntilOption = Schedule_dist_effectSchedule.recurUntilOption;
-exports.recurUpTo = Schedule_dist_effectSchedule.recurUpTo;
-exports.recurWhile = Schedule_dist_effectSchedule.recurWhile;
-exports.recurWhileEffect = Schedule_dist_effectSchedule.recurWhileEffect;
-exports.recurs = Schedule_dist_effectSchedule.recurs;
-exports.reduce = Schedule_dist_effectSchedule.reduce;
-exports.reduceEffect = Schedule_dist_effectSchedule.reduceEffect;
-exports.repeatForever = Schedule_dist_effectSchedule.repeatForever;
-exports.repetitions = Schedule_dist_effectSchedule.repetitions;
-exports.resetAfter = Schedule_dist_effectSchedule.resetAfter;
-exports.resetWhen = Schedule_dist_effectSchedule.resetWhen;
-exports.run = Schedule_dist_effectSchedule.run;
-exports.secondOfMinute = Schedule_dist_effectSchedule.secondOfMinute;
-exports.spaced = Schedule_dist_effectSchedule.spaced;
-exports.stop = Schedule_dist_effectSchedule.stop;
-exports.succeed = Schedule_dist_effectSchedule.succeed;
-exports.sync = Schedule_dist_effectSchedule.sync;
-exports.tapInput = Schedule_dist_effectSchedule.tapInput;
-exports.tapOutput = Schedule_dist_effectSchedule.tapOutput;
-exports.unfold = Schedule_dist_effectSchedule.unfold;
-exports.union = Schedule_dist_effectSchedule.union;
-exports.unionWith = Schedule_dist_effectSchedule.unionWith;
-exports.untilInput = Schedule_dist_effectSchedule.untilInput;
-exports.untilInputEffect = Schedule_dist_effectSchedule.untilInputEffect;
-exports.untilOutput = Schedule_dist_effectSchedule.untilOutput;
-exports.untilOutputEffect = Schedule_dist_effectSchedule.untilOutputEffect;
-exports.upTo = Schedule_dist_effectSchedule.upTo;
-exports.whileInput = Schedule_dist_effectSchedule.whileInput;
-exports.whileInputEffect = Schedule_dist_effectSchedule.whileInputEffect;
-exports.whileOutput = Schedule_dist_effectSchedule.whileOutput;
-exports.whileOutputEffect = Schedule_dist_effectSchedule.whileOutputEffect;
-exports.windowed = Schedule_dist_effectSchedule.windowed;
-exports.zipLeft = Schedule_dist_effectSchedule.zipLeft;
-exports.zipRight = Schedule_dist_effectSchedule.zipRight;
-exports.zipWith = Schedule_dist_effectSchedule.zipWith;
+require('../../dist/configProvider-93617d6d.cjs.prod.js');
+require('../../dist/config-d0ddc159.cjs.prod.js');
+require('../../ConfigError/dist/effect-ConfigError.cjs.prod.js');
+require('../../dist/configError-33e55472.cjs.prod.js');
+require('../../dist/configSecret-d1caca55.cjs.prod.js');
+require('../../dist/pathPatch-15c8d723.cjs.prod.js');
+require('../../dist/Ref-a3a4e50d.cjs.prod.js');
+require('../../Random/dist/effect-Random.cjs.prod.js');
+require('../../ScheduleDecision/dist/effect-ScheduleDecision.cjs.prod.js');
+require('../../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.prod.js');
+require('../../ScheduleInterval/dist/effect-ScheduleInterval.cjs.prod.js');
+require('../../dist/core-effect-c65770cd.cjs.prod.js');
+require('../../FiberRefs/dist/effect-FiberRefs.cjs.prod.js');
+require('../../dist/fiberRefs-be6b6a70.cjs.prod.js');
+require('../../dist/patch-c4d6c61e.cjs.prod.js');
+require('../../dist/label-655343b5.cjs.prod.js');
+require('../../LogLevel/dist/effect-LogLevel.cjs.prod.js');
+require('../../LogSpan/dist/effect-LogSpan.cjs.prod.js');
+require('../../Tracer/dist/effect-Tracer.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ScheduleTypeId = schedule.ScheduleTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ScheduleDriverTypeId = schedule.ScheduleDriverTypeId;
+
+/**
+ * @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 = schedule.makeWithState;
+
+/**
+ * Returns a new schedule with the given delay added to every interval defined
+ * by this schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const addDelay = schedule.addDelay;
+
+/**
+ * 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 = schedule.addDelayEffect;
+
+/**
+ * The same as `andThenEither`, but merges the output.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const andThen = schedule.andThen;
+
+/**
+ * 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 = schedule.andThenEither;
+
+/**
+ * Returns a new schedule that maps this schedule to a constant output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = schedule.as;
+
+/**
+ * Returns a new schedule that maps the output of this schedule to unit.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asUnit = schedule.asUnit;
+
+/**
+ * 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 = schedule.bothInOut;
+
+/**
+ * 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 = schedule.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
+ */
+const checkEffect = schedule.checkEffect;
+
+/**
+ * A schedule that recurs anywhere, collecting all inputs into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllInputs = schedule.collectAllInputs;
+
+/**
+ * Returns a new schedule that collects the outputs of this one into a chunk.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectAllOutputs = schedule.collectAllOutputs;
+
+/**
+ * A schedule that recurs until the condition f fails, collecting all inputs
+ * into a list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectUntil = schedule.collectUntil;
+
+/**
+ * A schedule that recurs until the effectful condition f fails, collecting
+ * all inputs into a list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectUntilEffect = schedule.collectUntilEffect;
+
+/**
+ * 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 = schedule.collectWhile;
+
+/**
+ * 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 = schedule.collectWhileEffect;
+
+/**
+ * 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 = schedule.compose;
+
+/**
+ * Returns a new schedule that deals with a narrower class of inputs than this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInput = schedule.mapInput;
+
+/**
+ * Transforms the context being provided to this schedule with the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = schedule.mapInputContext;
+
+/**
+ * Returns a new schedule that deals with a narrower class of inputs than this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputEffect = schedule.mapInputEffect;
+
+/**
+ * A schedule that always recurs, which counts the number of recurrences.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const count = schedule.count;
+
+/**
+ * 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 = schedule.dayOfMonth;
+
+/**
+ * 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 = schedule.dayOfWeek;
+
+/**
+ * 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 = schedule.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 constructors
+ */
+const delayedEffect = schedule.delayedEffect;
+
+/**
+ * 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 = schedule.delayedSchedule;
+
+/**
+ * Returns a new schedule that outputs the delay between each occurence.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const delays = schedule.delays;
+
+/**
+ * Returns a new schedule that maps both the input and output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBoth = schedule.mapBoth;
+
+/**
+ * Returns a new schedule that maps both the input and output.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBothEffect = schedule.mapBothEffect;
+
+/**
+ * Returns a driver that can be used to step the schedule, appropriately
+ * handling sleeping.
+ *
+ * @since 2.0.0
+ * @category getter
+ */
+const driver = schedule.driver;
+
+/**
+ * A schedule that can recur one time, the specified amount of time into the
+ * future.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const duration = schedule.duration;
+
+/**
+ * Returns a new schedule that performs a geometric union on the intervals
+ * defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const either = schedule.either;
+
+/**
+ * The same as `either` followed by `map`.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const eitherWith = schedule.eitherWith;
+
+/**
+ * A schedule that occurs everywhere, which returns the total elapsed duration
+ * since the first step.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const elapsed = schedule.elapsed;
+
+/**
+ * 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 = schedule.ensuring;
+
+/**
+ * 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 = schedule.exponential;
+
+/**
+ * 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 = schedule.fibonacci;
+
+/**
+ * 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 = schedule.fixed;
+
+/**
+ * A schedule that always recurs, producing a count of repeats: 0, 1, 2.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forever = schedule.forever;
+
+/**
+ * A schedule that recurs once with the specified delay.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromDelay = schedule.fromDelay;
+
+/**
+ * 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 = schedule.fromDelays;
+
+/**
+ * A schedule that always recurs, mapping input values through the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromFunction = schedule.fromFunction;
+
+/**
+ * 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 = schedule.hourOfDay;
+
+/**
+ * A schedule that always recurs, which returns inputs as outputs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const identity = schedule.identity;
+
+/**
+ * Returns a new schedule that performs a geometric intersection on the
+ * intervals defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersect = schedule.intersect;
+
+/**
+ * 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 = schedule.intersectWith;
+
+/**
+ * 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 = schedule.jittered;
+
+/**
+ * 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 = schedule.jitteredWith;
+
+/**
+ * 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 = schedule.linear;
+
+/**
+ * Returns a new schedule that maps the output of this schedule through the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = schedule.map;
+
+/**
+ * Returns a new schedule that maps the output of this schedule through the
+ * specified effectful function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = schedule.mapEffect;
+
+/**
+ * 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 = schedule.minuteOfHour;
+
+/**
+ * Returns a new schedule that modifies the delay using the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const modifyDelay = schedule.modifyDelay;
+
+/**
+ * Returns a new schedule that modifies the delay using the specified
+ * effectual function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const modifyDelayEffect = schedule.modifyDelayEffect;
+
+/**
+ * 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 = schedule.onDecision;
+
+/**
+ * A schedule that recurs one time.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const once = schedule.once;
+
+/**
+ * Returns a new schedule that passes through the inputs of this schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const passthrough = schedule.passthrough;
+
+/**
+ * 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 = schedule.provideContext;
+
+/**
+ * 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 = schedule.provideService;
+
+/**
+ * A schedule that recurs for until the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUntil = schedule.recurUntil;
+
+/**
+ * A schedule that recurs for until the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUntilEffect = schedule.recurUntilEffect;
+
+/**
+ * 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 = schedule.recurUntilOption;
+
+/**
+ * A schedule that recurs during the given duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurUpTo = schedule.recurUpTo;
+
+/**
+ * A schedule that recurs for as long as the predicate evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurWhile = schedule.recurWhile;
+
+/**
+ * A schedule that recurs for as long as the effectful predicate evaluates to
+ * true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const recurWhileEffect = schedule.recurWhileEffect;
+
+/**
+ * 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 = schedule.recurs;
+
+/**
+ * Returns a new schedule that folds over the outputs of this one.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce = schedule.reduce;
+
+/**
+ * Returns a new schedule that effectfully folds over the outputs of this one.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduceEffect = schedule.reduceEffect;
+
+/**
+ * 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 = schedule.forever;
+
+/**
+ * Returns a new schedule that outputs the number of repetitions of this one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repetitions = schedule.repetitions;
+
+/**
+ * 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 = schedule.resetAfter;
+
+/**
+ * Resets the schedule when the specified predicate on the schedule output
+ * evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const resetWhen = schedule.resetWhen;
+
+/**
+ * Runs a schedule using the provided inputs, and collects all outputs.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = schedule.run;
+
+/**
+ * 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 = schedule.secondOfMinute;
+
+/**
+ * Returns a schedule that recurs continuously, each repetition spaced the
+ * specified duration from the last run.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const spaced = schedule.spaced;
+
+/**
+ * A schedule that does not recur, it just stops.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const stop = schedule.stop;
+
+/**
+ * Returns a schedule that repeats one time, producing the specified constant
+ * value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = schedule.succeed;
+
+/**
+ * Returns a schedule that repeats one time, producing the specified constant
+ * value.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const sync = schedule.sync;
+
+/**
+ * Returns a new schedule that effectfully processes every input to this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapInput = schedule.tapInput;
+
+/**
+ * Returns a new schedule that effectfully processes every output from this
+ * schedule.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapOutput = schedule.tapOutput;
+
+/**
+ * Unfolds a schedule that repeats one time from the specified state and
+ * iterator.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfold = schedule.unfold;
+
+/**
+ * Returns a new schedule that performs a geometric union on the intervals
+ * defined by both schedules.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const union = schedule.union;
+
+/**
+ * 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 = schedule.unionWith;
+
+/**
+ * Returns a new schedule that continues until the specified predicate on the
+ * input evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilInput = schedule.untilInput;
+
+/**
+ * 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 = schedule.untilInputEffect;
+
+/**
+ * Returns a new schedule that continues until the specified predicate on the
+ * output evaluates to true.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const untilOutput = schedule.untilOutput;
+
+/**
+ * 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 = schedule.untilOutputEffect;
+
+/**
+ * A schedule that recurs during the given duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const upTo = schedule.upTo;
+
+/**
+ * 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 = schedule.whileInput;
+
+/**
+ * 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 = schedule.whileInputEffect;
+
+/**
+ * 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 = schedule.whileOutput;
+
+/**
+ * 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 = schedule.whileOutputEffect;
+
+/**
+ * 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 = schedule.windowed;
+
+/**
+ * The same as `intersect` but ignores the right output.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = schedule.zipLeft;
+
+/**
+ * The same as `intersect` but ignores the left output.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = schedule.zipRight;
+
+/**
+ * Equivalent to `intersect` followed by `map`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = schedule.zipWith;
+
+exports.ScheduleDriverTypeId = ScheduleDriverTypeId;
+exports.ScheduleTypeId = ScheduleTypeId;
+exports.addDelay = addDelay;
+exports.addDelayEffect = addDelayEffect;
+exports.andThen = andThen;
+exports.andThenEither = andThenEither;
+exports.as = as;
+exports.asUnit = asUnit;
+exports.bothInOut = bothInOut;
+exports.check = check;
+exports.checkEffect = checkEffect;
+exports.collectAllInputs = collectAllInputs;
+exports.collectAllOutputs = collectAllOutputs;
+exports.collectUntil = collectUntil;
+exports.collectUntilEffect = collectUntilEffect;
+exports.collectWhile = collectWhile;
+exports.collectWhileEffect = collectWhileEffect;
+exports.compose = compose;
+exports.count = count;
+exports.dayOfMonth = dayOfMonth;
+exports.dayOfWeek = dayOfWeek;
+exports.delayed = delayed;
+exports.delayedEffect = delayedEffect;
+exports.delayedSchedule = delayedSchedule;
+exports.delays = delays;
+exports.driver = driver;
+exports.duration = duration;
+exports.either = either;
+exports.eitherWith = eitherWith;
+exports.elapsed = elapsed;
+exports.ensuring = ensuring;
+exports.exponential = exponential;
+exports.fibonacci = fibonacci;
+exports.fixed = fixed;
+exports.forever = forever;
+exports.fromDelay = fromDelay;
+exports.fromDelays = fromDelays;
+exports.fromFunction = fromFunction;
+exports.hourOfDay = hourOfDay;
+exports.identity = identity;
+exports.intersect = intersect;
+exports.intersectWith = intersectWith;
+exports.jittered = jittered;
+exports.jitteredWith = jitteredWith;
+exports.linear = linear;
+exports.makeWithState = makeWithState;
+exports.map = map;
+exports.mapBoth = mapBoth;
+exports.mapBothEffect = mapBothEffect;
+exports.mapEffect = mapEffect;
+exports.mapInput = mapInput;
+exports.mapInputContext = mapInputContext;
+exports.mapInputEffect = mapInputEffect;
+exports.minuteOfHour = minuteOfHour;
+exports.modifyDelay = modifyDelay;
+exports.modifyDelayEffect = modifyDelayEffect;
+exports.onDecision = onDecision;
+exports.once = once;
+exports.passthrough = passthrough;
+exports.provideContext = provideContext;
+exports.provideService = provideService;
+exports.recurUntil = recurUntil;
+exports.recurUntilEffect = recurUntilEffect;
+exports.recurUntilOption = recurUntilOption;
+exports.recurUpTo = recurUpTo;
+exports.recurWhile = recurWhile;
+exports.recurWhileEffect = recurWhileEffect;
+exports.recurs = recurs;
+exports.reduce = reduce;
+exports.reduceEffect = reduceEffect;
+exports.repeatForever = repeatForever;
+exports.repetitions = repetitions;
+exports.resetAfter = resetAfter;
+exports.resetWhen = resetWhen;
+exports.run = run;
+exports.secondOfMinute = secondOfMinute;
+exports.spaced = spaced;
+exports.stop = stop;
+exports.succeed = succeed;
+exports.sync = sync;
+exports.tapInput = tapInput;
+exports.tapOutput = tapOutput;
+exports.unfold = unfold;
+exports.union = union;
+exports.unionWith = unionWith;
+exports.untilInput = untilInput;
+exports.untilInputEffect = untilInputEffect;
+exports.untilOutput = untilOutput;
+exports.untilOutputEffect = untilOutputEffect;
+exports.upTo = upTo;
+exports.whileInput = whileInput;
+exports.whileInputEffect = whileInputEffect;
+exports.whileOutput = whileOutput;
+exports.whileOutputEffect = whileOutputEffect;
+exports.windowed = windowed;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;