@fncts/io 0.0.1

package/IO/api/environment.d.ts

@@ -0,0 +1,74 @@
+import { IO, URIO, FIO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Tag } from "@fncts/base/data/Tag";
+import type * as Intersection from "@fncts/typelevel/Intersection";
+/**
+ * Provides some of the environment required to run this `IO`,
+ * leaving the remainder `R0`.
+ * @tsplus fluent fncts.io.IO contramapEnvironment
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function contramapEnvironment_<R0, R, E, A>(self: IO<R, E, A>, f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): IO<R0, E, A>;
+/**
+ * Accesses the environment provided to an `IO`
+ * @tsplus static fncts.io.IOOps environment
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function environment<R>(__tsplusTrace?: string): URIO<R, Environment<R>>;
+/**
+ * Accesses the environment provided to an `IO`
+ * @tsplus static fncts.io.IOOps environmentWith
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function environmentWith<R, A>(f: (_: Environment<R>) => A, __tsplusTrace?: string): URIO<R, A>;
+/**
+ * Effectfully accesses the environment provided to an `IO`
+ * @tsplus static fncts.io.IOOps environmentWithIO
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function environmentWithIO<R0, R, E, A>(f: (r: Environment<R0>) => IO<R, E, A>, __tsplusTrace?: string): IO<R & R0, E, A>;
+/**
+ * Provides all of the environment required to compute a MonadEnv
+ *
+ * Provides the `IO` with its required environment, which eliminates
+ * its dependency on `R`.
+ * @tsplus fluent fncts.io.IO provideEnvironment
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function provideEnvironment_<R, E, A>(self: IO<R, E, A>, r: Environment<R>, __tsplusTrace?: string): FIO<E, A>;
+/**
+ * @tsplus fluent fncts.io.IO provideSomeEnvironment
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function provideSomeEnvironment_<R, E, A, R0>(self: IO<R, E, A>, environment: Environment<R0>, __tsplusTrace?: string): IO<Intersection.Erase<R, R0>, E, A>;
+/**
+ * @tsplus fluent fncts.io.IO provideService
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function provideService_<E, A, T>(self: IO<Has<T>, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): FIO<E, A>;
+/**
+ * @tsplus fluent fncts.io.IO provideSomeService
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function provideSomeService_<R, E, A, T>(self: IO<R, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): IO<Intersection.Erase<R, Has<T>>, E, A>;
+/**
+ * @tsplus static fncts.io.IOAspects provideSomeService
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<R & import("@fncts/base/typeclass").Has<T>, E, A>) => import("../definition").IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps service
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<Has<T>, never, T>;
+/**
+ * @tsplus static fncts.io.IOOps serviceWith
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>): IO<Has<S>, never, A>;
+/**
+ * @tsplus static fncts.io.IOOps serviceWithIO
+ * @tsplus location "@fncts/io/IO/api/environment"
+ */
+export declare function serviceWithIO<T, R, E, A>(f: (service: T) => IO<R, E, A>, tag: Tag<T>, __tsplusTrace?: string): IO<R & Has<T>, E, A>;

package/IO/api/foreachC.d.ts

@@ -0,0 +1,29 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Queue } from "@fncts/io/Queue/definition";
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and runs
+ * produced effects in parallel, discarding the results.
+ *
+ * For a sequential version of this method, see `IO.foreachDiscard`.
+ *
+ * Optimized to avoid keeping full tree of effects, so that method could be
+ * able to handle large input sequences.
+ * Behaves almost like this code:
+ *
+ * Additionally, interrupts all effects on any failure.
+ * @tsplus static fncts.io.IOOps foreachDiscardC
+ * @tsplus fluent fncts.Iterable traverseIODiscardC
+ * @tsplus location "@fncts/io/IO/api/foreachC"
+ */
+export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void>;
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a `Conc<B>`.
+ *
+ * For a sequential version of this method, see `IO.foreach`.
+ * @tsplus static fncts.io.IOOps foreachC
+ * @tsplus fluent fncts.Iterable traverseIOC
+ * @tsplus location "@fncts/io/IO/api/foreachC"
+ */
+export declare function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;

package/IO/api/foreachExec.d.ts

@@ -0,0 +1,12 @@
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ * @tsplus static fncts.io.IOOps foreachExec
+ * @tsplus location "@fncts/io/IO/api/foreachExec"
+ */
+export declare function foreachExec_<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;

package/IO/api/forkAll.d.ts

@@ -0,0 +1,10 @@
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Returns an effect that forks all of the specified values, and returns a
+ * composite fiber that produces a list of their results, in order.
+ * @tsplus static fncts.io.IOOps forkAll
+ * @tsplus location "@fncts/io/IO/api/forkAll"
+ */
+export declare function forkAll<R, E, A>(as: Iterable<IO<R, E, A>>, __tsplusTrace?: string): URIO<R, Fiber<E, Conc<A>>>;

package/IO/api/forkIn.d.ts

@@ -0,0 +1,9 @@
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * Forks the workflow in the specified scope. The fiber will be interrupted
+ * when the scope is closed.
+ * @tsplus fluent fncts.io.IO forkIn
+ * @tsplus location "@fncts/io/IO/api/forkIn"
+ */
+export declare function forkIn_<R, E, A>(self: IO<R, E, A>, scope: Scope, __tsplusTrace?: string): URIO<R, Fiber.Runtime<E, A>>;

package/IO/api/forkScoped.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus getter fncts.io.IO forkScoped
+ * @tsplus location "@fncts/io/IO/api/forkScoped"
+ */
+export declare function forkScoped<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R & Has<Scope>, never, Fiber.Runtime<E, A>>;

package/IO/api/fulfill.d.ts

@@ -0,0 +1,10 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+/**
+ * Returns an IO that keeps or breaks a promise based on the result of
+ * this effect. Synchronizes interruption, so if this effect is interrupted,
+ * the specified promise will be interrupted, too.
+ * @tsplus fluent fncts.io.IO fulfill
+ * @tsplus location "@fncts/io/IO/api/fulfill"
+ */
+export declare function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>): IO<R, never, boolean>;

package/IO/api/interrupt.d.ts

@@ -0,0 +1,108 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import { FIO, IO } from "@fncts/io/IO/definition";
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import { Lazy } from "@fncts/base/data/function";
+/**
+ * Returns an effect that is interrupted as if by the specified fiber.
+ * @tsplus static fncts.io.IOOps interruptAs
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function interruptAs(fiberId: FiberId, __tsplusTrace?: string): FIO<never, never>;
+/**
+ * Returns an effect that is interrupted as if by the fiber calling this
+ * method.
+ * @tsplus static fncts.io.IOOps interrupt
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare const interrupt: IO<unknown, never, never>;
+/**
+ * Switches the interrupt status for this effect. If `true` is used, then the
+ * effect becomes interruptible (the default), while if `false` is used, then
+ * the effect becomes uninterruptible. These changes are compositional, so
+ * they only affect regions of the effect.
+ * @tsplus fluent fncts.io.IO setInterruptStatus
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function setInterruptStatus_<R, E, A>(self: IO<R, E, A>, flag: InterruptStatus, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Returns a new effect that performs the same operations as this effect, but
+ * interruptibly, even if composed inside of an uninterruptible region.
+ *
+ * Note that effects are interruptible by default, so this function only has
+ * meaning if used within an uninterruptible region.
+ *
+ * WARNING: This operator "punches holes" into effects, allowing them to be
+ * interrupted in unexpected places. Do not use this operator unless you know
+ * exactly what you are doing. Instead, you should use `uninterruptibleMask`.
+ * @tsplus getter fncts.io.IO interruptible
+ * @tsplus static fncts.io.IOOps interruptible
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Performs this effect uninterruptibly. This will prevent the effect from
+ * being terminated externally, but the effect may fail for internal reasons
+ * (e.g. an uncaught error) or terminate due to defect.
+ *
+ * Uninterruptible effects may recover from all failure causes (including
+ * interruption of an inner effect that has been made interruptible).
+ * @tsplus getter fncts.io.IO uninterruptible
+ * @tsplus static fncts.io.IOOps uninterruptible
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Makes the effect uninterruptible, but passes it a restore function that
+ * can be used to restore the inherited interruptibility from whatever region
+ * the effect is composed into.
+ * @tsplus static fncts.io.IOOps uninterruptibleMask
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * Makes the effect interruptible, but passes it a restore function that can
+ * be used to restore the inherited interruptibility from whatever region the
+ * effect is composed into.
+ * @tsplus static fncts.io.IOOps interruptibleMask
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * Calls the specified function, and runs the effect it returns, if this
+ * effect is interrupted.
+ * @tsplus fluent fncts.io.IO onInterrupt
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: ReadonlySet<FiberId>) => IO<R1, never, any>): IO<R & R1, E, A>;
+/**
+ * Calls the specified function, and runs the effect it returns, if this
+ * effect is interrupted (allows for expanding error).
+ * @tsplus fluent fncts.io.IO onInterruptExtended
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>): IO<R & R2, E | E2, A>;
+/**
+ * Returns an IO whose interruption will be disconnected from the
+ * fiber's own interruption, being performed in the background without
+ * slowing down the fiber's interruption.
+ *
+ * This method is useful to create "fast interrupting" effects. For
+ * example, if you call this on a bracketed effect, then even if the
+ * effect is "stuck" in acquire or release, its interruption will return
+ * immediately, while the acquire / release are performed in the
+ * background.
+ *
+ * See timeout and race for other applications.
+ * @tsplus getter fncts.io.IO disconnect
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Used to restore the inherited interruptibility
+ */
+export declare class InterruptStatusRestore {
+    readonly flag: InterruptStatus;
+    constructor(flag: InterruptStatus);
+    restore: <R, E, A>(io: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R, E, A>;
+    force: <R, E, A>(io: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R, E, A>;
+}

package/IO/api/memoize.d.ts

@@ -0,0 +1,6 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus getter fncts.io.IO memoize
+ * @tsplus location "@fncts/io/IO/api/memoize"
+ */
+export declare function memoize<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): UIO<IO<R, E, A>>;

package/IO/api/onExit.d.ts

@@ -0,0 +1,7 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus fluent fncts.io.IO onExit
+ * @tsplus location "@fncts/io/IO/api/onExit"
+ */
+export declare function onExit_<R, E, A, R1, E1>(self: IO<R, E, A>, cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>): IO<R & R1, E | E1, A>;

package/IO/api/once.d.ts

@@ -0,0 +1,6 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus getter fncts.io.IO once
+ * @tsplus location "@fncts/io/IO/api/once"
+ */
+export declare function once<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): UIO<IO<R, E, void>>;

package/IO/api/provideLayer.d.ts

@@ -0,0 +1,7 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Layer } from "@fncts/io/Layer";
+/**
+ * @tsplus fluent fncts.io.IO provideLayer
+ * @tsplus location "@fncts/io/IO/api/provideLayer"
+ */
+export declare function provideLayer_<RIn, E, ROut, E1, A>(self: IO<ROut, E1, A>, layer: Layer<RIn, E, ROut>): IO<RIn, E | E1, A>;

package/IO/api/provideSomeLayer.d.ts

@@ -0,0 +1,13 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Layer } from "@fncts/io/Layer";
+import type { Erase } from "@fncts/typelevel/Intersection";
+/**
+ * @tsplus fluent fncts.io.IO provideSomeLayer
+ * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
+ */
+export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: IO<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): IO<RIn & Erase<R, ROut>, E | E1, A>;
+/**
+ * @tsplus static fncts.io.IOAspects provideSomeLayer
+ * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
+ */
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R & ROut, E, A>) => import("../definition").IO<R & RIn, E1 | E, A>;

package/IO/api/race.d.ts

@@ -0,0 +1,13 @@
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * Returns an IO that races this effect with the specified effect,
+ * returning the first successful `A` from the faster side. If one effect
+ * succeeds, the other will be interrupted. If neither succeeds, then the
+ * effect will fail with some error.
+ *
+ * WARNING: The raced effect will safely interrupt the "loser", but will not
+ * resume until the loser has been cleanly terminated.
+ * @tsplus fluent fncts.io.IO race
+ * @tsplus location "@fncts/io/IO/api/race"
+ */
+export declare function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1>;

package/IO/api/raceFirst.d.ts

@@ -0,0 +1,16 @@
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * Returns an IO that races this effect with the specified effect,
+ * yielding the first result to complete, whether by success or failure. If
+ * neither effect completes, then the composed effect will not complete.
+ *
+ * WARNING: The raced effect will safely interrupt the "loser", but will not
+ * resume until the loser has been cleanly terminated. If early return is
+ * desired, then instead of performing `l.raceFirst(r)`, perform
+ * `l.disconnect raceFirst r.disconnect`, which disconnects left and right
+ * interrupt signal, allowing a fast return, with interruption performed
+ * in the background.
+ * @tsplus fluent fncts.io.IO raceFirst
+ * @tsplus location "@fncts/io/IO/api/raceFirst"
+ */
+export declare function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1>;

package/IO/api/randomWith.d.ts

@@ -0,0 +1,12 @@
+import { Random } from "@fncts/io/Random/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.IOOps randomWith
+ * @tsplus location "@fncts/io/IO/api/randomWith"
+ */
+export declare function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps random
+ * @tsplus location "@fncts/io/IO/api/randomWith"
+ */
+export declare const random: import("../definition").IO<unknown, never, import("../../Random").Random>;

package/IO/api/repeat.d.ts

@@ -0,0 +1,20 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either";
+/**
+ * @tsplus getter fncts.io.IO repeat
+ * @tsplus location "@fncts/io/IO/api/repeat"
+ */
+export declare function repeat_<R, E, A>(self: IO<R, E, A>): <R1, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, __tsplusTrace?: string) => import("../definition").IO<R & R1, E, B>;
+/**
+ * @tsplus getter fncts.io.IO repeatOrElse
+ * @tsplus location "@fncts/io/IO/api/repeat"
+ */
+export declare function repeatOrElse_<R, E, A>(self: IO<R, E, A>): <R1, B, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, B>;
+/**
+ * @tsplus getter fncts.io.IO repeatOrElseEither
+ * @tsplus location "@fncts/io/IO/api/repeat"
+ */
+export declare function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>): <R1, B, R2, E2, C>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, C>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, import("@fncts/base/data/Either").Either<C, B>>;

package/IO/api/retry.d.ts

@@ -0,0 +1,19 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Either } from "@fncts/base/data/Either";
+/**
+ * @tsplus getter fncts.io.IO retry
+ * @tsplus location "@fncts/io/IO/api/retry"
+ */
+export declare function retry<R, E, A>(self: IO<R, E, A>): <R1, O>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, __tsplusTrace?: string) => import("../definition").IO<R & R1, E, A>;
+/**
+ * @tsplus getter fncts.io.IO retryOrElse
+ * @tsplus location "@fncts/io/IO/api/retry"
+ */
+export declare function retryOrElse<R, E, A>(self: IO<R, E, A>): <R1, O, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, A>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, A>;
+/**
+ * @tsplus getter fncts.io.IO retryOrElseEither
+ * @tsplus location "@fncts/io/IO/api/retry"
+ */
+export declare function retryOrElseEither_<R, E, A>(self: IO<R, E, A>): <R1, O, R2, E2, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, import("@fncts/base/data/Either").Either<B, A>>;

package/IO/api/schedule.d.ts

@@ -0,0 +1,13 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Schedule } from "@fncts/io/Schedule/definition";
+/**
+ * @tsplus fluent fncts.io.IO scheduleFrom
+ * @tsplus location "@fncts/io/IO/api/schedule"
+ */
+export declare function scheduleFrom<R, E, A extends A1, R1, A1, B>(self: IO<R, E, A>, a: Lazy<A>, schedule0: Lazy<Schedule<R1, A1, B>>): IO<R & R1, E, B>;
+/**
+ * @tsplus fluent fncts.io.IO schedule
+ * @tsplus location "@fncts/io/IO/api/schedule"
+ */
+export declare function schedule<R, E, A, R1, B>(io: IO<R, E, A>, schedule: Lazy<Schedule<R1, any, B>>, __tsplusTrace?: string): IO<R & R1, E, B>;

package/IO/api/scope.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps scope
+ * @tsplus location "@fncts/io/IO/api/scope"
+ */
+export declare const scope: IO<Has<Scope>, never, Scope>;

package/IO/api/scopeWith.d.ts

@@ -0,0 +1,8 @@
+import { Scope } from "@fncts/io/Scope/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+/**
+ * @tsplus static fncts.io.IOOps scopeWith
+ * @tsplus location "@fncts/io/IO/api/scopeWith"
+ */
+export declare function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>): IO<R & Has<Scope>, E, A>;

package/IO/api/scoped.d.ts

@@ -0,0 +1,14 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps scoped
+ * @tsplus location "@fncts/io/IO/api/scoped"
+ */
+export declare function scoped<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+/**
+ * @tsplus getter fncts.io.IO scoped
+ * @tsplus location "@fncts/io/IO/api/scoped"
+ */
+export declare function scoped_<R, E, A>(io: IO<R & Has<Scope>, E, A>): IO<R, E, A>;

package/IO/api/sequenceT.d.ts

@@ -0,0 +1,10 @@
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray";
+import { IO } from "@fncts/io/IO/definition";
+import type { _A, _E, _R } from "@fncts/base/types";
+/**
+ * @tsplus static fncts.io.IOOps sequenceT
+ * @tsplus location "@fncts/io/IO/api/sequenceT"
+ */
+export declare function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(...ios: T): IO<_R<T[number]>, _E<T[number]>, {
+    [K in keyof T]: _A<T[K]>;
+}>;

package/IO/api/sleep.d.ts

@@ -0,0 +1,6 @@
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.IOOps sleep
+ * @tsplus location "@fncts/io/IO/api/sleep"
+ */
+export declare function sleep(duration: number, __tsplusTrace?: string): UIO<void>;

package/IO/api/stateful.d.ts

@@ -0,0 +1,10 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Tag } from "@fncts/base/data/Tag";
+import { State } from "../../State.js";
+/**
+ * @tsplus static fncts.io.IOOps stateful
+ * @tsplus location "@fncts/io/IO/api/stateful"
+ */
+export declare function stateful<S, R, E, A>(s: S, io: Lazy<IO<Has<State<S>> & R, E, A>>, tag: Tag<State<S>>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/withChildren.d.ts

@@ -0,0 +1,7 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.io.IOOps withChildren
+ * @tsplus location "@fncts/io/IO/api/withChildren"
+ */
+export declare function withChildren<R, E, A>(get: (_: UIO<Conc<Fiber.Runtime<any, any>>>) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/withFinalizer.d.ts

@@ -0,0 +1,8 @@
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus fluent fncts.io.IO withFinalizer
+ * @tsplus location "@fncts/io/IO/api/withFinalizer"
+ */
+export declare function withFinalizer_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A) => URIO<R1, any>): IO<R & R1 & Has<Scope>, E, A>;

package/IO/api/withFinalizerExit.d.ts

@@ -0,0 +1,9 @@
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus fluent fncts.io.IO withFinalizerExit
+ * @tsplus location "@fncts/io/IO/api/withFinalizerExit"
+ */
+export declare function withFinalizerExit_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>): IO<R & R1 & Has<Scope>, E, A>;

package/IO/api/withRuntimeConfig.d.ts

@@ -0,0 +1,10 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+/**
+ * Runs the specified effect on the specified runtime configuration, restoring
+ * the old runtime configuration when it completes execution.
+ * @tsplus fluent fncts.io.IO withRuntimeConfig
+ * @tsplus location "@fncts/io/IO/api/withRuntimeConfig"
+ */
+export declare function withRuntimeConfig_<R, E, A>(self: IO<R, E, A>, runtimeConfig: Lazy<RuntimeConfig>): IO<R, E, A>;

package/IO/api/zipC.d.ts

@@ -0,0 +1,6 @@
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.io.IO zipC
+ * @tsplus location "@fncts/io/IO/api/zipC"
+ */
+export declare function zipC_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>): IO<R & R1, E | E1, readonly [A, B]>;

package/IO/api/zipWithC.d.ts

@@ -0,0 +1,9 @@
+import { IO } from "@fncts/io/IO/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Exit } from "@fncts/base/data/Exit";
+import { Fiber } from "@fncts/io/Fiber/definition";
+/**
+ * @tsplus fluent fncts.io.IO zipWithC
+ * @tsplus location "@fncts/io/IO/api/zipWithC"
+ */
+export declare function zipWithC_<R, E, A, R1, E1, B, C>(self: IO<R, E, A>, that: IO<R1, E1, B>, f: (a: A, b: B) => C): IO<R & R1, E | E1, C>;