@fncts/io 0.0.1

package/STM/internal/Journal.d.ts

@@ -0,0 +1,101 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { STM } from "@fncts/io/STM/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { IO } from "@fncts/io/IO/definition";
+import type { Entry } from "./Entry.js";
+import type { TryCommit } from "./TryCommit.js";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Atomic } from "@fncts/io/TRef";
+import type { TxnId } from "@fncts/io/TxnId";
+import { CommitState } from "./CommitState.js";
+import { Done } from "./TryCommit.js";
+/**
+ * @tsplus type fncts.io.Journal
+ */
+export declare type Journal = Map<Atomic<any>, Entry>;
+/**
+ * @tsplus type fncts.io.JournalOps
+ */
+export interface JournalOps {
+}
+export declare const Journal: JournalOps;
+export declare type Todo = () => unknown;
+/**
+ * Creates a function that can reset the journal.
+ * @tsplus fluent fncts.io.Journal prepareReset
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function prepareResetJournal(journal: Journal): () => unknown;
+/**
+ * Commits the journal.
+ * @tsplus fluent fncts.io.Journal commit
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function commitJournal(journal: Journal): void;
+declare type Invalid = -1;
+declare const Invalid = -1;
+declare type ReadOnly = 0;
+declare const ReadOnly = 0;
+declare type ReadWrite = 1;
+declare const ReadWrite = 1;
+declare type JournalAnalysis = Invalid | ReadOnly | ReadWrite;
+/**
+ * Analyzes the journal, determining whether it is valid and whether it is
+ * read only in a single pass. Note that information on whether the
+ * journal is read only will only be accurate if the journal is valid, due
+ * to short-circuiting that occurs on an invalid journal.
+ * @tsplus fluent fncts.io.Journal analyze
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function analyzeJournal(journal: Journal): JournalAnalysis;
+/**
+ * @tsplus static fncts.io.JournalOps emptyTodoMap
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare const emptyTodoMap: import("@fncts/base/collection/immutable/HashMap.js").HashMap<number, Todo>;
+/**
+ * Atomically collects and clears all the todos from any `TRef` that
+ * participated in the transaction.
+ * @tsplus getter fncts.io.Journal collectTodos
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function collectTodos(journal: Journal): Map<TxnId, Todo>;
+/**
+ * Executes the todos in the current thread, sequentially.
+ * @tsplus fluent fncts.io.Journal execTodos
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function execTodos(todos: Map<TxnId, Todo>): void;
+/**
+ * Runs all the todos.
+ * @tsplus fluent fncts.io.Journal completeTodos
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>): Done<E, A>;
+/**
+ * For the given transaction id, adds the specified todo effect to all
+ * `TRef` values.
+ * @tsplus fluent fncts.io.Journal addTodo
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function addTodo(journal: Journal, txnId: TxnId, todoEffect: Todo): boolean;
+/**
+ * Finds all the new todo targets that are not already tracked in the `oldJournal`.
+ */
+export declare function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal): Journal;
+export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>): TryCommit<E, A>;
+export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<CommitState<E, A>>, r: Environment<R>): (k: (_: IO<R, E, A>) => unknown) => void;
+/**
+ * Determines if the journal is valid.
+ * @tsplus getter fncts.io.Journal isValid
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function isValid(journal: Journal): boolean;
+/**
+ * Determines if the journal is invalid.
+ * @tsplus getter fncts.io.Journal isInvalid
+ * @tsplus location "@fncts/io/STM/internal/Journal"
+ */
+export declare function isInvalid(journal: Journal): boolean;
+export {};

package/STM/internal/TryCommit.d.ts

@@ -0,0 +1,21 @@
+import { Exit } from "@fncts/base/data/Exit";
+import type { Journal } from "./Journal.js";
+export declare const TryCommitTypeId: unique symbol;
+export declare type TryCommitTypeId = typeof TryCommitTypeId;
+export declare type TryCommit<E, A> = Done<E, A> | Suspend;
+export declare const enum TryCommitTag {
+    Done = "Done",
+    Suspend = "Suspend"
+}
+export declare class Done<E, A> {
+    readonly exit: Exit<E, A>;
+    readonly _typeId: TryCommitTypeId;
+    readonly _tag = TryCommitTag.Done;
+    constructor(exit: Exit<E, A>);
+}
+export declare class Suspend {
+    readonly journal: Journal;
+    readonly _typeId: TryCommitTypeId;
+    readonly _tag = TryCommitTag.Suspend;
+    constructor(journal: Journal);
+}

package/STM/internal/Versioned.d.ts

@@ -0,0 +1,7 @@
+export declare const VersionedTypeId: unique symbol;
+export declare type VersionedTypeId = typeof VersionedTypeId;
+export declare class Versioned<A> {
+    readonly value: A;
+    readonly _typeId: VersionedTypeId;
+    constructor(value: A);
+}

package/STM.d.ts

@@ -0,0 +1,5 @@
+export * from "./STM/api.js";
+export * from "./STM/definition.js";
+export * from "./STM/driver.js";
+export * from "./STM/api/core-api.js";
+export * from "./STM/api/core-constructors.js";

package/Schedule/Decision.d.ts

@@ -0,0 +1,38 @@
+import type { Interval } from "./Interval.js";
+export declare const enum DecisionTag {
+    Continue = "Continue",
+    Done = "Done"
+}
+export declare class Continue {
+    readonly interval: Interval;
+    readonly _tag = DecisionTag.Continue;
+    constructor(interval: Interval);
+}
+export declare class Done {
+    readonly _tag = DecisionTag.Done;
+}
+/**
+ * @tsplus type fncts.io.Schedule.Decision
+ */
+export declare type Decision = Continue | Done;
+/**
+ * @tsplus type fncts.io.Schedule.DecisionOps
+ */
+export interface DecisionOps {
+}
+export declare const Decision: DecisionOps;
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps Done
+ * @tsplus location "@fncts/io/Schedule/Decision"
+ */
+export declare const done: Decision;
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps Continue
+ * @tsplus location "@fncts/io/Schedule/Decision"
+ */
+export declare function continue_(interval: Interval): Decision;
+/**
+ * @tsplus fluent fncts.io.Schedule.Decision match
+ * @tsplus location "@fncts/io/Schedule/Decision"
+ */
+export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Interval) => B): A | B;

package/Schedule/Driver.d.ts

@@ -0,0 +1,19 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Nothing } from "@fncts/base/data/Maybe";
+import { NoSuchElementError } from "@fncts/base/data/exceptions";
+/**
+ * @tsplus type fncts.io.Schedule.Driver
+ * @tsplus companion fncts.io.Schedule.DriverOps
+ */
+export declare class Driver<State, Env, In, Out> {
+    readonly next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>;
+    readonly last: IO<unknown, NoSuchElementError, Out>;
+    readonly reset: UIO<void>;
+    readonly state: UIO<State>;
+    constructor(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>);
+}
+/**
+ * @tsplus static fncts.io.Schedule.DriverOps __call
+ * @tsplus location "@fncts/io/Schedule/Driver"
+ */
+export declare function makeDriver<State, Env, In, Out>(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>): Driver<State, Env, In, Out>;

package/Schedule/Interval.d.ts

@@ -0,0 +1,71 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus type fncts.io.Schedule.Interval
+ * @tsplus companion fncts.io.Schedule.IntervalOps
+ */
+export declare class Interval {
+    readonly startMilliseconds: number;
+    readonly endMilliseconds: number;
+    constructor(startMilliseconds: number, endMilliseconds: number);
+}
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps after
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function after(start: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps before
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function before(end: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps empty
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare const empty: Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isEmpty
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function isEmpty(self: Interval): boolean;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function intersect_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval lt
+ * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function lt_(self: Interval, that: Interval): boolean;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps __call
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function makeInterval(start: number, end: number): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function max_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function min_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function isNonEmpty(self: Interval): boolean;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval size
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function size(self: Interval): number;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus location "@fncts/io/Schedule/Interval"
+ */
+export declare function union_(self: Interval, that: Interval): Maybe<Interval>;

package/Schedule/api/driver.d.ts

@@ -0,0 +1,7 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus getter fncts.io.Schedule driver
+ * @tsplus location "@fncts/io/Schedule/api/driver"
+ */
+export declare function driver<State, Env, In, Out>(schedule: Schedule.WithState<State, Env, In, Out>, __tsplusTrace?: string): UIO<Schedule.Driver<State, Env, In, Out>>;

package/Schedule/api.d.ts

@@ -0,0 +1,359 @@
+import { IO, URIO, UIO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either";
+import { Lazy } from "@fncts/base/data/function";
+import { Environment } from "@fncts/base/data/Environment";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { List } from "@fncts/base/collection/immutable/List";
+import { Decision } from "./Decision.js";
+import { Interval } from "./Interval.js";
+/**
+ * @tsplus static fncts.io.ScheduleOps __call
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function make<State, Env, In, Out>(initial: State, step: (now: number, inp: In, state: State, __tsplusTrace?: string) => IO<Env, never, readonly [State, Out, Decision]>): Schedule.WithState<State, Env, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule addDelay
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function addDelay_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => number): Schedule.WithState<State, Env, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule addDelayIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function addDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, number>): Schedule.WithState<State, Env & Env1, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule andThen
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>): Schedule.WithState<readonly [State, State1, boolean], Env & Env1, In & In1, Out | Out1>;
+/**
+ * @tsplus fluent fncts.io.Schedule andThenEither
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>): Schedule.WithState<readonly [State, State1, boolean], Env & Env1, In & In1, Either<Out, Out1>>;
+/**
+ * @tsplus fluent fncts.io.Schedule as
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function as_<State, Env, In, Out, Out2>(self: Schedule.WithState<State, Env, In, Out>, out2: Lazy<Out2>): Schedule.WithState<State, Env, In, Out2>;
+/**
+ * @tsplus fluent fncts.io.Schedule check
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function check_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => boolean): Schedule.WithState<State, Env, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule checkIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function checkIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => URIO<Env1, boolean>): Schedule.WithState<State, Env & Env1, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule compose_
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function compose_<S, R, I, O, S1, R1, O2>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, O, O2>): Schedule.WithState<readonly [S, S1], R & R1, I, O2>;
+/**
+ * @tsplus fluent fncts.io.Schedule contramap
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function contramap_<S, R, I, O, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => I): Schedule.WithState<S, R, I2, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule contramapEnvironment
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function contramapEnvironment_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (env: Environment<R1>) => Environment<R>): Schedule.WithState<S, R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule contramapIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function contramapIO_<S, R, I, O, R1, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => URIO<R1, I>): Schedule.WithState<S, R & R1, I2, O>;
+/**
+ * @tsplus static fncts.io.ScheduleOps delayed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>): Schedule.WithState<S, R, I, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule delayed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function delayedSelf_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => number): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule delayedIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function delayedIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => URIO<R1, number>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus getter fncts.io.Schedule delays
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule dimap
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function dimap_<S, R, I, O, I2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => I, g: (out: O) => O2): Schedule.WithState<S, R, I2, O2>;
+/**
+ * @tsplus fluent fncts.io.Schedule dimapIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function dimapIO_<S, R, I, O, R1, I2, R2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>): Schedule.WithState<S, R & R1 & R2, I2, O2>;
+/**
+ * @tsplus static fncts.io.ScheduleOps duration
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function duration(duration: number): Schedule.WithState<boolean, unknown, unknown, number>;
+/**
+ * @tsplus static fncts.io.ScheduleOps elapsed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const elapsed: Schedule.WithState<Maybe<number>, unknown, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule ensuring
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function ensuring_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, finalizer: UIO<any>): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus static fncts.io.ScheduleOps exponential
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function exponential(base: number, factor?: number): Schedule.WithState<number, unknown, unknown, number>;
+/**
+ * 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|-----------|
+ * ```
+ * @tsplus static fncts.io.ScheduleOps fixed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function fixed(interval: number): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], unknown, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule fold
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function fold_<S, R, I, O, Z>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => Z): Schedule.WithState<readonly [S, Z], R, I, Z>;
+/**
+ * @tsplus fluent fncts.io.Schedule foldIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function foldIO_<S, R, I, O, Z, R1>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => URIO<R1, Z>): Schedule.WithState<readonly [S, Z], R & R1, I, Z>;
+/**
+ * @tsplus getter fncts.io.Schedule forever
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function foreverSelf<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus static fncts.io.ScheduleOps forever
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const forever: import("./definition.js").Schedule.WithState<number, unknown, unknown, number>;
+/**
+ * @tsplus static fncts.io.ScheduleOps identity
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function identity<A>(): Schedule.WithState<void, unknown, A, A>;
+/**
+ * @tsplus fluent fncts.io.Schedule intersectWith
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function intersectWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Interval, int2: Interval) => Interval): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+/**
+ * @tsplus static fncts.io.Schedule linear
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function linear(base: number): Schedule.WithState<number, unknown, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule map
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function map_<State, Env, In, Out, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => Out1): Schedule.WithState<State, Env, In, Out1>;
+/**
+ * @tsplus fluent fncts.io.Schedule mapIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function mapIO_<State, Env, In, Out, Env1, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, Out1>): Schedule.WithState<State, Env & Env1, In, Out1>;
+/**
+ * @tsplus fluent fncts.io.Schedule modifyDelayIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function modifyDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out, duration: number) => URIO<Env1, number>): Schedule.WithState<State, Env & Env1, In, Out>;
+/**
+ * @tsplus fluent fncts.io.Schedule onDecision
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function onDecision_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule provideEnvironment
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function provideEnvironment_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, env: Environment<R>): Schedule.WithState<S, unknown, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule reconsider
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function reconsider_<S, R, I, O, O2>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>): Schedule.WithState<S, R, I, O2>;
+/**
+ * @tsplus fluent fncts.io.Schedule reconsiderIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function reconsiderIO_<S, R, I, O, R1, O1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>): Schedule.WithState<S, R & R1, I, O1>;
+/**
+ * @tsplus static fncts.io.Schedule recurs
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurs(n: number): Schedule.WithState<number, unknown, unknown, number>;
+/**
+ * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurWhile<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A>;
+/**
+ * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A>;
+/**
+ * @tsplus static fncts.io.Schedule recurWhileEquals
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurWhileEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A>;
+/**
+ * @tsplus static fncts.io.Schedule recurUntil
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurUntil<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A>;
+/**
+ * @tsplus static fncts.io.Schedule recurUntilIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A>;
+/**
+ * @tsplus static fncts.io.Schedule recurUntilEquals
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function recurUntilEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A>;
+/**
+ * @tsplus getter fncts.io.Schedule repetitions
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, number], R, I, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule resetAfter
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function resetAfter_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, duration: number): Schedule.WithState<readonly [S, Maybe<number>], R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule resetWhen
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function resetWhen_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule run
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function run_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, now: number, input: Iterable<I>): URIO<R, Conc<O>>;
+/**
+ * @tsplus static fncts.io.Schedule spaced
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function spaced(duration: number): Schedule.WithState<number, unknown, unknown, number>;
+/**
+ * @tsplus static fncts.io.Schedule succeed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function succeed<A>(a: Lazy<A>): Schedule.WithState<number, unknown, unknown, A>;
+/**
+ * @tsplus fluent fncts.io.Schedule tapInput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function tapInput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule tapOutput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function tapOutput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule unionWith
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function unionWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Interval, int2: Interval) => Interval): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+/**
+ * @tsplus static fncts.io.ScheduleOps unfold
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function unfold<A>(a: Lazy<A>, f: (a: A) => A): Schedule.WithState<A, unknown, unknown, A>;
+/**
+ * @tsplus fluent fncts.io.Schedule untilInput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function untilInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule untilInputIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function untilInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule untilOutput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function untilOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule untilOutputIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function untilOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus static fncts.io.Schedule upTo
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function upTo(duration: number): Schedule.WithState<Maybe<number>, unknown, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule whileInput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function whileInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule whileInputIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function whileInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule whileOutput
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function whileOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule whileOutputIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function whileOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+/**
+ * @tsplus static fncts.io.Schedule windowed
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function windowed(interval: number): Schedule.WithState<readonly [Maybe<number>, number], unknown, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule zip
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function zip_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+/**
+ * @tsplus fluent fncts.io.Schedule zipLeft
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function zipLeft_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O>;
+/**
+ * @tsplus fluent fncts.io.Schedule zipRight
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function zipRight_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O1>;
+/**
+ * @tsplus fluent fncts.io.Schedule zipWith
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function zipWith_<S, R, I, O, S1, R1, I1, O2, O3>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O3>;