import type { Either } from "../../Either";
import * as T from "../Task/_core";
import type { Decision } from "./Decision";
import type { Schedule } from "./model";
/**
 * Returns a new schedule that loops this one continuously, resetting the state
 * when this schedule is done.
 */
export declare const repeat: <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
export declare const modifyDelayM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (o: O, d: number) => T.Task<R1, never, number>
) => Schedule<R & R1, I, O>;
export declare const modifyDelayM: <R1, O>(
   f: (o: O, d: number) => T.Task<R1, never, number>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
export declare const modifyDelay_: <R, I, O>(
   sc: Schedule<R, I, O>,
   f: (o: O, d: number) => number
) => Schedule<R, I, O>;
export declare const modifyDelay: <O>(
   f: (o: O, d: number) => number
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule with the effectfully calculated delay added to every update.
 */
export declare const addDelayM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (o: O) => T.Task<R1, never, number>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule with the effectfully calculated delay added to every update.
 */
export declare const addDelayM: <R1, O>(
   f: (o: O) => T.Task<R1, never, number>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule with the given delay added to every update.
 */
export declare const addDelay_: <R, I, O>(sc: Schedule<R, I, O>, f: (o: O) => number) => Schedule<R, I, O>;
/**
 * Returns a new schedule with the given delay added to every update.
 */
export declare const addDelay: <O>(f: (o: O) => number) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new `Schedule` with the specified effectfully computed delay added before the start
 * of each interval produced by the this `Schedule`.
 */
export declare const delayedM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (d: number) => T.Task<R1, never, number>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new `Schedule` with the specified effectfully computed delay added before the start
 * of each interval produced by the this `Schedule`.
 */
export declare const delayedM: <R1>(
   f: (d: number) => T.Task<R1, never, number>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule with the specified computed delay added before the start
 * of each interval produced by this schedule.
 */
export declare const delayed_: <R, I, O>(sc: Schedule<R, I, O>, f: (d: number) => number) => Schedule<R, I, O>;
/**
 * Returns a new schedule with the specified computed delay added before the start
 * of each interval produced by this schedule.
 */
export declare const delayed: (f: (d: number) => number) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
export declare const duration: (n: number) => Schedule<unknown, unknown, number>;
/**
 * Returns a new schedule with the specified computed delay added before the start
 * of each interval produced by this schedule.
 */
export declare const delayedFrom: <R, I>(sc: Schedule<R, I, number>) => Schedule<R, I, number>;
/**
 * Returns a new schedule that first executes this schedule to completion, and then executes the
 * specified schedule to completion.
 */
export declare const andThenEither_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, Either<O, O1>>;
/**
 * Returns a new schedule that first executes this schedule to completion, and then executes the
 * specified schedule to completion.
 */
export declare const andThenEither: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, Either<O, O1>>;
export declare const mapM_: <R, I, O, R1, O1>(
   sc: Schedule<R, I, O>,
   f: (o: O) => T.Task<R1, never, O1>
) => Schedule<R & R1, I, O1>;
export declare const mapM: <R1, O, O1>(
   f: (o: O) => T.Task<R1, never, O1>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O1>;
export declare const map_: <R, I, A, B>(fa: Schedule<R, I, A>, f: (a: A) => B) => Schedule<R, I, B>;
export declare const map: <A, B>(f: (a: A) => B) => <R, I>(fa: Schedule<R, I, A>) => Schedule<R, I, B>;
export declare const as_: <R, I, O, O1>(sc: Schedule<R, I, O>, o: O1) => Schedule<R, I, O1>;
export declare const as: <O1>(o: O1) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, I, O1>;
/**
 * Returns a new schedule that maps the output of this schedule to unit.
 */
export declare const unit: <R, I, O, R1>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, void>;
export declare const combineWith_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>,
   f: (d1: number, d2: number) => number
) => Schedule<R & R1, I & I1, [O, O1]>;
export declare const combineWith: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => (f: (d1: number, d2: number) => number) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, [O, O1]>;
export declare const either_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, [O, O1]>;
export declare const either: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, [O, O1]>;
export declare const eitherWith_: <R, I, O, R1, I1, O1, O2>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>,
   f: (o: O, o1: O1) => O2
) => Schedule<R & R1, I & I1, O2>;
export declare const eitherWith: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <O, O2>(f: (o: O, o1: O1) => O2) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, O2>;
/**
 * Returns a new schedule that has both the inputs and outputs of this and the specified
 * schedule.
 */
export declare const bothInOut_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, readonly [I, I1], readonly [O, O1]>;
/**
 * Returns a new schedule that has both the inputs and outputs of this and the specified
 * schedule.
 */
export declare const bothInOut: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, readonly [I, I1], readonly [O, O1]>;
/**
 * Returns a new schedule that performs a geometric intersection on the intervals defined
 * by both schedules.
 */
export declare const both_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, [O, O1]>;
/**
 * Returns a new schedule that performs a geometric intersection on the intervals defined
 * by both schedules.
 */
export declare const both: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(self: Schedule<R, I, O>) => Schedule<R & R1, I & I1, readonly [O, O1]>;
/**
 * 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.
 */
export declare const checkM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   test: (i: I, o: O) => T.Task<R1, never, boolean>
) => Schedule<R & R1, I, O>;
/**
 * 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.
 */
export declare const checkM: <R1, I, O>(
   test: (i: I, o: O) => T.Task<R1, never, boolean>
) => <R>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that passes each input and output of this schedule to the spefcified
 * function, and then determines whether or not to continue based on the return value of the
 * function.
 */
export declare const check_: <R, I, O>(sc: Schedule<R, I, O>, test: (i: I, o: O) => boolean) => Schedule<R, I, O>;
/**
 * Returns a new schedule that passes each input and output of this schedule to the spefcified
 * function, and then determines whether or not to continue based on the return value of the
 * function.
 */
export declare const check: <I, O>(test: (i: I, o: O) => boolean) => <R>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilInput_: <R, I, O>(sc: Schedule<R, I, O>, f: (i: I) => boolean) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilInput: <I>(f: (i: I) => boolean) => <R, O>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilInputM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (i: I) => T.Task<R1, never, boolean>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilInputM: <R1, I>(
   f: (i: I) => T.Task<R1, never, boolean>
) => <R, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilOutput_: <R, I, O>(sc: Schedule<R, I, O>, f: (o: O) => boolean) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilOutput: <O>(f: (o: O) => boolean) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilOutputM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (o: O) => T.Task<R1, never, boolean>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues until the specified predicate on the input evaluates
 * to true.
 */
export declare const untilOutputM: <R1, O>(
   f: (o: O) => T.Task<R1, never, boolean>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileInput_: <R, I, O>(sc: Schedule<R, I, O>, f: (i: I) => boolean) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileInput: <I>(f: (i: I) => boolean) => <R, O>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileInputM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (i: I) => T.Task<R1, never, boolean>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileInputM: <R1, I>(
   f: (i: I) => T.Task<R1, never, boolean>
) => <R, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileOutput_: <R, I, O>(sc: Schedule<R, I, O>, f: (o: O) => boolean) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileOutput: <O>(f: (o: O) => boolean) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileOutputM_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (o: O) => T.Task<R1, never, boolean>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that continues for as long the specified effectful predicate on the
 * input evaluates to true.
 */
export declare const whileOutputM: <R1, O>(
   f: (o: O) => T.Task<R1, never, boolean>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that allows choosing between feeding inputs to this schedule, or
 * feeding inputs to the specified schedule.
 */
export declare const choose_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, Either<I, I1>, Either<O, O1>>;
/**
 * Returns a new schedule that allows choosing between feeding inputs to this schedule, or
 * feeding inputs to the specified schedule.
 */
export declare const choose: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, Either<I, I1>, Either<O, O1>>;
/**
 * Returns a new schedule that allows choosing between feeding inputs to this schedule, or
 * feeding inputs to the specified schedule.
 */
export declare const chooseMerge_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, Either<I, I1>, O | O1>;
/**
 * Returns a new schedule that allows choosing between feeding inputs to this schedule, or
 * feeding inputs to the specified schedule.
 */
export declare const chooseMerge: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, Either<I, I1>, O1 | O>;
/**
 * Returns a new schedule that will run the specified finalizer as soon as the schedule is
 * complete. Note that unlike `Task#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.
 */
export declare const ensuring_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   finalizer: T.Task<R1, never, any>
) => Schedule<R & R1, I, O>;
/**
 * Returns a new schedule that will run the specified finalizer as soon as the schedule is
 * complete. Note that unlike `Task#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.
 */
export declare const ensuring: <R1>(
   finalizer: T.Task<R1, never, any>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
/**
 * 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".
 *
 * <pre>
 * |-----interval-----|-----interval-----|-----interval-----|
 * |---------action--------||action|-----|action|-----------|
 * </pre>
 */
export declare const fixed: (interval: number) => Schedule<unknown, unknown, number>;
/**
 * Returns a new `Schedule` that effectfully folds over the outputs of a `Schedule`.
 */
export declare const foldM_: <R, I, O, R1, B>(
   sc: Schedule<R, I, O>,
   b: B,
   f: (b: B, o: O) => T.Task<R1, never, B>
) => Schedule<R & R1, I, B>;
/**
 * Returns a new `Schedule` that effectfully folds over the outputs of a `Schedule`.
 */
export declare const foldM: <R1, O, B>(
   b: B,
   f: (b: B, o: O) => T.Task<R1, never, B>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, B>;
/**
 * Returns a new `Schedule` that folds over the outputs of a `Schedule`.
 */
export declare const fold_: <R, I, O, B>(sc: Schedule<R, I, O>, b: B, f: (b: B, o: O) => B) => Schedule<R, I, B>;
/**
 * Returns a new `Schedule` that folds over the outputs of a `Schedule`.
 */
export declare const fold: <O, B>(b: B, f: (b: B, o: O) => B) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, B>;
/**
 * Unfolds a schedule that repeats one time from the specified state and iterator.
 */
export declare const unfold_: <A>(a: () => A, f: (a: A) => A) => Schedule<unknown, unknown, A>;
/**
 * Unfolds a schedule that repeats one time from the specified state and iterator.
 */
export declare const unfold: <A>(f: (a: A) => A) => (a: () => A) => Schedule<unknown, unknown, A>;
/**
 * Taskfully unfolds a schedule that repeats one time from the specified state and iterator.
 */
export declare const unfoldM_: <R, A>(a: A, f: (a: A) => T.Task<R, never, A>) => Schedule<R, unknown, A>;
/**
 * Taskfully unfolds a schedule that repeats one time from the specified state and iterator.
 */
export declare const unfoldM: <R, A>(f: (a: A) => T.Task<R, never, A>) => (a: A) => Schedule<R, unknown, A>;
/**
 * A schedule that recurs forever and produces a count of repeats.
 */
export declare const forever: Schedule<unknown, unknown, number>;
/**
 * A schedule spanning all time, which can be stepped only the specified number of times before
 * it terminates.
 */
export declare const recur: (n: number) => Schedule<unknown, unknown, number>;
/**
 * A `Schedule` that recurs one time.
 */
export declare const once: Schedule<unknown, unknown, void>;
/**
 * A `Schedule` that stops
 */
export declare const stop: Schedule<unknown, unknown, void>;
/**
 * Returns a new schedule that randomly modifies the size of the intervals of this schedule.
 */
export declare const jittered_: <R, I, O>(
   sc: Schedule<R, I, O>,
   {
      max,
      min
   }?: {
      min?: number | undefined;
      max?: number | undefined;
   }
) => Schedule<R & import("../../Has").Has<import("../Random").Random>, I, O>;
/**
 * Returns a new schedule that randomly modifies the size of the intervals of this schedule.
 */
export declare const jittered: ({
   max,
   min
}?: {
   min?: number | undefined;
   max?: number | undefined;
}) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & import("../../Has").Has<import("../Random").Random>, I, O>;
/**
 * 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.
 */
export declare const linear: (base: number) => Schedule<unknown, unknown, number>;
/**
 * Returns a new schedule that collects the outputs of a `Schedule` into an array.
 */
export declare const collectAll: <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, I, readonly O[]>;
/**
 * A schedule that always recurs and returns inputs as outputs.
 */
export declare const identity: <A>() => Schedule<unknown, A, A>;
/**
 * Returns a new schedule that makes this schedule available on the `Left` side of an `Either`
 * input, allowing propagating some type `X` through this channel on demand.
 */
export declare const left: <A>() => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, Either<I, A>, Either<O, A>>;
/**
 * Returns a new schedule that makes this schedule available on the `Right` side of an `Either`
 * input, allowing propagating some type `X` through this channel on demand.
 */
export declare const right: <A>() => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, Either<A, I>, Either<A, O>>;
/**
 * Returns a new schedule that packs the input and output of this schedule into the first
 * element of a tuple. This allows carrying information through this schedule.
 */
export declare const first: <A>() => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, readonly [I, A], readonly [O, A]>;
/**
 * Returns a new schedule that packs the input and output of this schedule into the second
 * element of a tuple. This allows carrying information through this schedule.
 */
export declare const second: <A>() => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, readonly [A, I], readonly [A, O]>;
/**
 * A schedule that always recurs, mapping input values through the
 * specified function.
 */
export declare const fromFunction: <A, B>(f: (a: A) => B) => Schedule<unknown, A, B>;
/**
 * Returns a schedule that recurs continuously, each repetition spaced the specified duration
 * from the last run.
 */
export declare const spaced: (duration: number) => Schedule<unknown, unknown, number>;
/**
 * Returns a new schedule with its environment provided to it, so the resulting
 * schedule does not require any environment.
 */
export declare const provideAll_: <R, I, O>(sc: Schedule<R, I, O>, r: R) => Schedule<unknown, I, O>;
/**
 * Returns a new schedule with its environment provided to it, so the resulting
 * schedule does not require any environment.
 */
export declare const provideAll: <R>(r: R) => <I, O>(sc: Schedule<R, I, O>) => Schedule<unknown, I, O>;
/**
 * Returns a new schedule with part of its environment provided to it, so the
 * resulting schedule does not require any environment.
 */
export declare const provideSome_: <R, R1, I, O>(sc: Schedule<R, I, O>, r: (_: R1) => R) => Schedule<R1, I, O>;
/**
 * Returns a new schedule with part of its environment provided to it, so the
 * resulting schedule does not require any environment.
 */
export declare const provideSome: <R, R1>(r: (_: R1) => R) => <I, O>(sc: Schedule<R, I, O>) => Schedule<R1, I, O>;
/**
 * Returns a new schedule that effectfully reconsiders every decision made by this schedule,
 * possibly modifying the next interval and the output type in the process.
 */
export declare const reconsiderM_: <R, I, O, R1, O1>(
   sc: Schedule<R, I, O>,
   f: (d: Decision<R, I, O>) => T.Task<R1, never, Either<O1, [O1, number]>>
) => Schedule<R & R1, I, O1>;
/**
 * Returns a new schedule that effectfully reconsiders every decision made by this schedule,
 * possibly modifying the next interval and the output type in the process.
 */
export declare const reconsiderM: <R, I, O, R1, O1>(
   f: (d: Decision<R, I, O>) => T.Task<R1, never, Either<O1, [O1, number]>>
) => (sc: Schedule<R, I, O>) => Schedule<R & R1, I, O1>;
/**
 * Returns a new schedule that reconsiders every decision made by this schedule,
 * possibly modifying the next interval and the output type in the process.
 */
export declare const reconsider_: <R, I, O, O1>(
   sc: Schedule<R, I, O>,
   f: (d: Decision<R, I, O>) => Either<O1, [O1, number]>
) => Schedule<R, I, O1>;
/**
 * Returns a new schedule that reconsiders every decision made by this schedule,
 * possibly modifying the next interval and the output type in the process.
 */
export declare const reconsider: <R, I, O, O1>(
   f: (d: Decision<R, I, O>) => Either<O1, [O1, number]>
) => (sc: Schedule<R, I, O>) => Schedule<R, I, O1>;
/**
 * A schedule that recurs for as long as the effectful predicate evaluates to true.
 */
export declare const recurWhileM: <R, A>(f: (a: A) => T.Task<R, never, boolean>) => Schedule<R, A, A>;
/**
 * A schedule that recurs for as long as the predicate evaluates to true.
 */
export declare const recurWhile: <A>(f: (a: A) => boolean) => Schedule<unknown, A, A>;
/**
 * A schedule that recurs for as long as the predicate evaluates to true.
 */
export declare const recurWhileEqual: <A>(a: A) => Schedule<unknown, A, A>;
/**
 * A schedule that recurs until the effectful predicate evaluates to true.
 */
export declare const recurUntilM: <R, A>(f: (a: A) => T.Task<R, never, boolean>) => Schedule<R, A, A>;
/**
 * A schedule that recurs until the predicate evaluates to true.
 */
export declare const recurUntil: <A>(f: (a: A) => boolean) => Schedule<unknown, A, A>;
/**
 * A schedule that recurs until the predicate evaluates to true.
 */
export declare const recurUntilEqual: <A>(a: A) => Schedule<unknown, A, A>;
/**
 * Returns a new schedule that outputs the number of repetitions of this one.
 */
export declare const repetitions: <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R, I, number>;
/**
 * Resets the schedule when the specified predicate on the schedule output evaluates to true.
 */
export declare const resetWhen_: <R, I, O>(sc: Schedule<R, I, O>, f: (o: O) => boolean) => Schedule<R, I, O>;
/**
 * Resets the schedule when the specified predicate on the schedule output evaluates to true.
 */
export declare const resetWhen: <O>(f: (o: O) => boolean) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R, I, O>;
export declare const run_: <R, I, O>(
   sc: Schedule<R, I, O>,
   now: number,
   i: Iterable<I>
) => T.Task<R, never, readonly O[]>;
export declare const run: <I>(
   now: number,
   i: Iterable<I>
) => <R, O>(sc: Schedule<R, I, O>) => T.Task<R, never, readonly O[]>;
/**
 * 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.
 */
export declare const onDecision_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (d: Decision<R, I, O>) => T.Task<R1, never, any>
) => Schedule<R & R1, I, O>;
/**
 * 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.
 */
export declare const onDecision: <R, I, O, R1>(
   f: (d: Decision<R, I, O>) => T.Task<R1, never, any>
) => (sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
export declare const tapInput_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (i: I) => T.Task<R1, never, any>
) => Schedule<R & R1, I, O>;
export declare const tapInput: <R1, I>(
   f: (i: I) => T.Task<R1, never, any>
) => <R, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
export declare const tapOutput_: <R, I, O, R1>(
   sc: Schedule<R, I, O>,
   f: (o: O) => T.Task<R1, never, any>
) => Schedule<R & R1, I, O>;
export declare const tapOutput: <R1, O>(
   f: (o: O) => T.Task<R1, never, any>
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I, O>;
export declare const windowed: (interval: number) => Schedule<unknown, unknown, number>;
/**
 * Returns a new schedule that performs a geometric intersection on the intervals defined
 * by both schedules.
 */
export declare const zip_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, [O, O1]>;
/**
 * Returns a new schedule that performs a geometric intersection on the intervals defined
 * by both schedules.
 */
export declare const zip: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, [O, O1]>;
/**
 * Same as zip but ignores the right output.
 */
export declare const zipl_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, O>;
/**
 * Same as zip but ignores the right output.
 */
export declare const zipl: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, O>;
/**
 * Same as zip but ignores the left output.
 */
export declare const zipr_: <R, I, O, R1, I1, O1>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>
) => Schedule<R & R1, I & I1, O1>;
/**
 * Same as zip but ignores the left output.
 */
export declare const zipr: <R1, I1, O1>(
   that: Schedule<R1, I1, O1>
) => <R, I, O>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, O1>;
/**
 * Equivalent to `zip` followed by `map`.
 */
export declare const zipWith_: <R, I, O, R1, I1, O1, O2>(
   sc: Schedule<R, I, O>,
   that: Schedule<R1, I1, O1>,
   f: (o: O, o1: O1) => O2
) => Schedule<R & R1, I & I1, O2>;
/**
 * Equivalent to `zip` followed by `map`.
 */
export declare const zipWith: <R1, I1, O, O1, O2>(
   that: Schedule<R1, I1, O1>,
   f: (o: O, o1: O1) => O2
) => <R, I>(sc: Schedule<R, I, O>) => Schedule<R & R1, I & I1, O2>;
//# sourceMappingURL=combinators.d.ts.map