@fncts/io 0.0.20 → 0.0.22

package/Schedule/api.d.ts

@@ -1,5 +1,6 @@
 import { IO, URIO, UIO } from "@fncts/io/IO/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
@@ -15,121 +16,126 @@ import { Decision } from "./Decision.js";
  */
 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]>, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule addDelay
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
+export declare function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule addDelayIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
+export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule andThen
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1>;
+export declare function andThen<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<readonly [State, State1, boolean], Env1 | Env, In & In1, Out1 | Out>;
 /**
- * @tsplus fluent fncts.io.Schedule andThenEither
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>>;
+export declare function andThenEither<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<readonly [State, State1, boolean], Env1 | Env, In & In1, import("@fncts/base/data/Either.js").Either<Out, Out1>>;
 /**
- * @tsplus fluent fncts.io.Schedule as
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out2>;
+export declare function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out2>;
 /**
- * @tsplus fluent fncts.io.Schedule check
+ * @tsplus getter fncts.io.Schedule asUnit
  * @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, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
+export declare function asUnit<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, void>;
 /**
- * @tsplus fluent fncts.io.Schedule checkIO
+ * @tsplus pipeable fncts.io.Schedule check
  * @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>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
+export declare function check<In, Out>(test: (inp: In, out: Out) => boolean, __tsplusTrace?: string): <State, Env>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule compose_
+ * @tsplus pipeable fncts.io.Schedule checkIO
  * @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>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I, O2>;
+export declare function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, boolean>, __tsplusTrace?: string): <State, Env>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule contramap
+ * @tsplus pipeable fncts.io.Schedule compose_
  * @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, __tsplusTrace?: string): Schedule.WithState<S, R, I2, O>;
+export declare function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I, O2>;
 /**
- * @tsplus fluent fncts.io.Schedule contramapEnvironment
+ * @tsplus pipeable fncts.io.Schedule contramap
  * @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>, __tsplusTrace?: string): Schedule.WithState<S, R1, I, O>;
+export declare function contramap<I, I2>(f: (inp: I2) => I, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I2, O>;
 /**
- * @tsplus fluent fncts.io.Schedule contramapIO
+ * @tsplus pipeable fncts.io.Schedule contramapEnvironment
  * @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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I2, O>;
+export declare function contramapEnvironment<R, R1>(f: (env: Environment<R1>) => Environment<R>, __tsplusTrace?: string): <S, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1, I, O>;
+/**
+ * @tsplus pipeable fncts.io.Schedule contramapIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, 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>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
+export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, Duration>, __tsplusTrace?: string): Schedule.WithState<S, R, I, Duration>;
 /**
- * @tsplus fluent fncts.io.Schedule delayed
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule delayedIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, 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>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
 /**
- * @tsplus fluent fncts.io.Schedule dimap
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I2, O2>;
+export declare function dimap<I, O, I2, O2>(f: (inp2: I2) => I, g: (out: O) => O2, __tsplusTrace?: string): <S, R>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I2, O2>;
 /**
- * @tsplus fluent fncts.io.Schedule dimapIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1 | R2, I2, O2>;
+export declare function dimapIO<I, O, R1, I2, R2, O2>(f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>, __tsplusTrace?: string): <S, R>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R2 | R, I2, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps duration
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function duration(duration: number, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, number>;
+export declare function duration(duration: Duration, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, Duration>;
 /**
- * @tsplus fluent fncts.io.Schedule either
- * @tsplus operator fncts.io.Schedule ||
+ * @tsplus pipeable fncts.io.Schedule either
+ * @tsplus pipeable-operator fncts.io.Schedule ||
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function either<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+export declare function either<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
 /**
- * @tsplus fluent fncts.io.Schedule eitherWith
+ * @tsplus pipeable fncts.io.Schedule eitherWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function eitherWith<S, R, I, O, S1, R1, I1, O1, O2>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (out1: O, out2: O1) => O2, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2>;
+export declare function eitherWith<O, S1, R1, I1, O1, O2>(that: Schedule.WithState<S1, R1, I1, O1>, f: (out1: O, out2: O1) => O2, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
- * @tsplus fluent fncts.io.Schedule ensuring
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function ensuring(finalizer: UIO<any>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").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, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function exponential(base: Duration, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -144,22 +150,22 @@ export declare function exponential(base: number, factor?: number, __tsplusTrace
  * @tsplus static fncts.io.ScheduleOps fixed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fixed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
+export declare function fixed(interval: Duration, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
 /**
- * @tsplus fluent fncts.io.Schedule fold
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<readonly [S, Z], R, I, Z>;
+export declare function fold<O, Z>(z: Z, f: (z: Z, out: O) => Z, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, Z], R, I, Z>;
 /**
- * @tsplus fluent fncts.io.Schedule foldIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [S, Z], R | R1, I, Z>;
+export declare function foldIO<O, Z, R1>(z: Z, f: (z: Z, out: O) => URIO<R1, Z>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, Z], R1 | R, 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>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function repeatForever<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps forever
  * @tsplus location "@fncts/io/Schedule/api"
@@ -171,62 +177,72 @@ export declare const forever: import("./definition.js").Schedule.WithState<numbe
  */
 export declare function identity<A>(__tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
- * @tsplus fluent fncts.io.Schedule intersectWith
+ * @tsplus pipeable 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: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+export declare function intersectWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
 /**
  * @tsplus static fncts.io.Schedule linear
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function linear(base: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
+/**
+ * @tsplus pipeable fncts.io.Schedule map
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function map<Out, Out1>(f: (out: Out) => Out1, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out1>;
+/**
+ * @tsplus pipeable fncts.io.Schedule mapIO
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out1>;
 /**
- * @tsplus fluent fncts.io.Schedule map
+ * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  * @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, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out1>;
+export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: Duration) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
 /**
- * @tsplus fluent fncts.io.Schedule mapIO
+ * @tsplus static fncts.io.ScheduleOps once
  * @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>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out1>;
+export declare const once: Schedule.WithState<number, never, any, void>;
 /**
- * @tsplus fluent fncts.io.Schedule modifyDelayIO
+ * @tsplus static fncts.io.ScheduleOps asap
  * @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>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
+export declare const asap: import("./definition.js").Schedule.WithState<number, never, any, void>;
 /**
- * @tsplus fluent fncts.io.Schedule onDecision
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function onDecision<S, O, R1>(f: (state: S, out: O, decision: Decision) => URIO<R1, any>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule provideEnvironment
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, never, I, O>;
+export declare function provideEnvironment<R>(env: Environment<R>, __tsplusTrace?: string): <S, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, never, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule reconsider
+ * @tsplus pipeable 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]>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O2>;
+export declare function reconsider<S, O, O2>(f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O2>;
 /**
- * @tsplus fluent fncts.io.Schedule reconsiderIO
+ * @tsplus pipeable 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]>>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O1>;
+export declare function reconsiderIO<S, O, R1, O1>(f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O1>;
 /**
- * @tsplus static fncts.io.Schedule recurs
+ * @tsplus static fncts.io.ScheduleOps recurs
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
- * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus static fncts.io.ScheduleOps recurWhile
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
- * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus static fncts.io.ScheduleOps recurWhileIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>, __tsplusTrace?: string): Schedule.WithState<void, R, A, A>;
@@ -256,117 +272,117 @@ export declare function recurUntilEquals<A>(value: Lazy<A>, __tsplusTrace?: stri
  */
 export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, __tsplusTrace?: string): Schedule.WithState<readonly [S, number], R, I, number>;
 /**
- * @tsplus fluent fncts.io.Schedule resetAfter
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<readonly [S, Maybe<number>], R, I, O>;
+export declare function resetAfter(duration: Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, import("@fncts/base/data/Maybe.js").Maybe<number>], R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule resetWhen
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function resetWhen<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule run
+ * @tsplus pipeable 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>, __tsplusTrace?: string): URIO<R, Conc<O>>;
+export declare function run<I>(now: number, input: Iterable<I>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("../IO.js").URIO<R, import("@fncts/base/collection/immutable/Conc.js").Conc<O>>;
 /**
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function spaced(duration: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.Schedule succeed
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, A>;
 /**
- * @tsplus fluent fncts.io.Schedule tapInput
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function tapInput<I, R1>(f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule tapOutput
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function tapOutput<O, R1>(f: (out: O) => URIO<R1, any>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule unionWith
+ * @tsplus pipeable 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: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+export declare function unionWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, 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, __tsplusTrace?: string): Schedule.WithState<A, never, unknown, A>;
 /**
- * @tsplus fluent fncts.io.Schedule untilInput
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function untilInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule untilInputIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function untilInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule untilOutput
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function untilOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule untilOutputIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
  * @tsplus static fncts.io.Schedule upTo
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function upTo(duration: number, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare function upTo(duration: Duration, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
- * @tsplus fluent fncts.io.Schedule whileInput
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function whileInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule whileInputIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function whileInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule whileOutput
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
+export declare function whileOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
- * @tsplus fluent fncts.io.Schedule whileOutputIO
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
+export declare function whileOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
  * @tsplus static fncts.io.Schedule windowed
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function windowed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<number>, number], never, unknown, number>;
 /**
- * @tsplus fluent fncts.io.Schedule zip
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+export declare function zip<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
 /**
- * @tsplus fluent fncts.io.Schedule zipLeft
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O>;
+export declare function zipLeft<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O>;
 /**
- * @tsplus fluent fncts.io.Schedule zipRight
+ * @tsplus pipeable 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>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1>;
+export declare function zipRight<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O1>;
 /**
- * @tsplus fluent fncts.io.Schedule zipWith
+ * @tsplus pipeable 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, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3>;
+export declare function zipWith<O, S1, R1, I1, O2, O3>(that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O3>;

package/Scope/ReleaseMap/api/releaseAll.d.ts

@@ -3,7 +3,7 @@ import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { UIO } from "@fncts/io/IO/definition";
 import { ReleaseMap } from "../definition.js";
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap releaseAll
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap releaseAll
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api/releaseAll"
  */
-export declare function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy, __tsplusTrace?: string): UIO<any>;
+export declare function releaseAll(exit: Exit<any, any>, execStrategy: ExecutionStrategy, __tsplusTrace?: string): (releaseMap: ReleaseMap) => import("../../../IO.js").UIO<any>;

package/Scope/ReleaseMap/api.d.ts

@@ -4,27 +4,27 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { ReleaseMap } from "./definition.js";
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap addIfOpen
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap addIfOpen
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Maybe<number>>;
+export declare function addIfOpen(finalizer: Finalizer, __tsplusTrace?: string): (releaseMap: ReleaseMap) => import("../../IO.js").UIO<import("@fncts/base/data/Maybe.js").Maybe<number>>;
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap release
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap release
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>, __tsplusTrace?: string): IO<never, never, any>;
+export declare function release(key: number, exit: Exit<any, any>, __tsplusTrace?: string): (releaseMap: ReleaseMap) => IO<never, never, any>;
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap add
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap add
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function add_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Finalizer>;
+export declare function add(finalizer: Finalizer, __tsplusTrace?: string): (releaseMap: ReleaseMap) => import("../../IO.js").UIO<import("../Finalizer.js").Finalizer>;
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap replace
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap replace
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer, __tsplusTrace?: string): UIO<Maybe<Finalizer>>;
+export declare function replace(key: number, finalizer: Finalizer, __tsplusTrace?: string): (releaseMap: ReleaseMap) => import("../../IO.js").UIO<import("@fncts/base/data/Maybe.js").Maybe<import("../Finalizer.js").Finalizer>>;
 /**
- * @tsplus fluent fncts.io.Scope.ReleaseMap updateAll
+ * @tsplus pipeable fncts.io.Scope.ReleaseMap updateAll
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer, __tsplusTrace?: string): UIO<void>;
+export declare function updateAll(f: (_: Finalizer) => Finalizer, __tsplusTrace?: string): (releaseMap: ReleaseMap) => import("../../IO.js").UIO<void>;

package/Scope/ReleaseMap/definition.d.ts

@@ -3,7 +3,7 @@ import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype } from "@fncts/base/data/Newtype";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 export declare class Exited {
     readonly nextKey: number;
     readonly exit: Exit<any, any>;

package/Scope/api.d.ts

@@ -1,20 +1,20 @@
-import { Scope } from "@fncts/io/Scope/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Closeable } from "./definition.js";
 /**
- * @tsplus fluent fncts.io.Scope addFinalizer
+ * @tsplus pipeable fncts.io.Scope addFinalizer
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>, __tsplusTrace?: string): UIO<void>;
+export declare function addFinalizer(finalizer: Lazy<UIO<any>>, __tsplusTrace?: string): (self: Scope) => import("../IO.js").UIO<void>;
 /**
  * @tsplus static fncts.io.ScopeOps addFinalizer
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function addFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void>;
+export declare function makeAddFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void>;
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -22,10 +22,10 @@ export declare function addFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?:
  */
 export declare const concurrent: UIO<Scope.Closeable>;
 /**
- * @tsplus fluent fncts.io.Scope extend
+ * @tsplus pipeable fncts.io.Scope extend
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
+export declare function extend<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): (self: Scope) => IO<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus static fncts.io.ScopeOps global
  * @tsplus location "@fncts/io/Scope/api"
@@ -54,7 +54,7 @@ export declare function unsafeMake(__tsplusTrace?: string): Closeable;
  */
 export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy, __tsplusTrace?: string): Scope.Closeable;
 /**
- * @tsplus fluent fncts.io.Scope.Closeable use
+ * @tsplus pipeable fncts.io.Scope.Closeable use
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
+export declare function use<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): (self: Scope.Closeable) => IO<Exclude<R, Scope>, E, A>;

package/ScopedRef/api.d.ts

@@ -1,7 +1,7 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus static fncts.io.ScopedRefOps fromAcquire