effect 2.0.0-next.5 → 2.0.0-next.50

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

@@ -0,0 +1,1113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var schedule = require('../../dist/schedule-31e38871.cjs.dev.js');
+require('../../Chunk/dist/effect-Chunk.cjs.dev.js');
+require('../../Equal/dist/effect-Equal.cjs.dev.js');
+require('../../Hash/dist/effect-Hash.cjs.dev.js');
+require('../../Function/dist/effect-Function.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+require('../../Option/dist/effect-Option.cjs.dev.js');
+require('../../dist/Either-e7500e90.cjs.dev.js');
+require('../../dist/Option-01caa9d4.cjs.dev.js');
+require('../../dist/Effectable-71c10ab9.cjs.dev.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
+require('../../Either/dist/effect-Either.cjs.dev.js');
+require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
+require('../../Clock/dist/effect-Clock.cjs.dev.js');
+require('../../dist/defaultServices-6a9a2d2b.cjs.dev.js');
+require('../../Context/dist/effect-Context.cjs.dev.js');
+require('../../dist/Context-607e9b4c.cjs.dev.js');
+require('../../Duration/dist/effect-Duration.cjs.dev.js');
+require('../../dist/core-b4bf44d3.cjs.dev.js');
+require('../../Differ/dist/effect-Differ.cjs.dev.js');
+require('../../HashMap/dist/effect-HashMap.cjs.dev.js');
+require('../../dist/HashSet-c12c037b.cjs.dev.js');
+require('../../dist/Stack-ada2d201.cjs.dev.js');
+require('../../HashSet/dist/effect-HashSet.cjs.dev.js');
+require('../../dist/FiberId-6595cf4c.cjs.dev.js');
+require('../../MutableRef/dist/effect-MutableRef.cjs.dev.js');
+require('../../List/dist/effect-List.cjs.dev.js');
+require('../../dist/RuntimeFlagsPatch-7d62915d.cjs.dev.js');
+require('../../dist/timeout-d380d3f8.cjs.dev.js');
+require('../../dist/configProvider-3d85d4ef.cjs.dev.js');
+require('../../dist/config-8a7bf1ae.cjs.dev.js');
+require('../../ConfigError/dist/effect-ConfigError.cjs.dev.js');
+require('../../dist/configError-0c09b93c.cjs.dev.js');
+require('../../dist/configSecret-938818ad.cjs.dev.js');
+require('../../dist/pathPatch-31ce8101.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../dist/Ref-f990026b.cjs.dev.js');
+require('../../Random/dist/effect-Random.cjs.dev.js');
+require('../../ScheduleDecision/dist/effect-ScheduleDecision.cjs.dev.js');
+require('../../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.dev.js');
+require('../../ScheduleInterval/dist/effect-ScheduleInterval.cjs.dev.js');
+require('../../dist/core-effect-f4b1aad8.cjs.dev.js');
+require('../../FiberRefs/dist/effect-FiberRefs.cjs.dev.js');
+require('../../dist/fiberRefs-ccc37f30.cjs.dev.js');
+require('../../dist/patch-cda9b6c8.cjs.dev.js');
+require('../../dist/label-b0cebeae.cjs.dev.js');
+require('../../LogLevel/dist/effect-LogLevel.cjs.dev.js');
+require('../../LogSpan/dist/effect-LogSpan.cjs.dev.js');
+require('../../Tracer/dist/effect-Tracer.cjs.dev.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;