@fncts/io 0.0.10 → 0.0.13

package/Schedule/api.d.ts

@@ -4,6 +4,7 @@ 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 { Intervals } from "@fncts/base/data/Intervals";
 import { Interval } from "@fncts/base/data/Interval";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { List } from "@fncts/base/collection/immutable/List";
@@ -22,17 +23,17 @@ export declare function addDelay_<State, Env, In, Out>(self: Schedule.WithState<
  * @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>;
+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>;
+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>>;
+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"
@@ -47,12 +48,12 @@ export declare function check_<State, Env, In, Out>(self: Schedule.WithState<Sta
  * @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>;
+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>;
+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"
@@ -67,7 +68,7 @@ export declare function contramapEnvironment_<S, R, I, O, R1>(self: Schedule.Wit
  * @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>;
+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"
@@ -82,7 +83,7 @@ export declare function delayedSelf_<S, R, I, O>(self: Schedule.WithState<S, R,
  * @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>;
+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"
@@ -97,17 +98,28 @@ export declare function dimap_<S, R, I, O, I2, O2>(self: Schedule.WithState<S, R
  * @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>;
+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>;
+export declare function duration(duration: number): Schedule.WithState<boolean, never, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule either
+ * @tsplus 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>): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+/**
+ * @tsplus fluent 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): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const elapsed: Schedule.WithState<Maybe<number>, unknown, unknown, number>;
+export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule ensuring
  * @tsplus location "@fncts/io/Schedule/api"
@@ -117,7 +129,7 @@ export declare function ensuring_<S, R, I, O>(self: Schedule.WithState<S, R, I,
  * @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>;
+export declare function exponential(base: number, factor?: number): Schedule.WithState<number, never, unknown, number>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -132,7 +144,7 @@ export declare function exponential(base: number, factor?: number): Schedule.Wit
  * @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>;
+export declare function fixed(interval: number): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule fold
  * @tsplus location "@fncts/io/Schedule/api"
@@ -142,7 +154,7 @@ export declare function fold_<S, R, I, O, Z>(self: Schedule.WithState<S, R, I, O
  * @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>;
+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"
@@ -152,22 +164,22 @@ export declare function foreverSelf<S, R, I, O>(self: Schedule.WithState<S, R, I
  * @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>;
+export declare const forever: import("./definition.js").Schedule.WithState<number, never, 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>;
+export declare function identity<A>(): Schedule.WithState<void, never, 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]>;
+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): 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>;
+export declare function linear(base: number): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule map
  * @tsplus location "@fncts/io/Schedule/api"
@@ -177,22 +189,22 @@ export declare function map_<State, Env, In, Out, Out1>(self: Schedule.WithState
  * @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>;
+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>;
+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>;
+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>;
+export declare function provideEnvironment_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, env: Environment<R>): Schedule.WithState<S, never, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule reconsider
  * @tsplus location "@fncts/io/Schedule/api"
@@ -202,17 +214,17 @@ export declare function reconsider_<S, R, I, O, O2>(self: Schedule.WithState<S,
  * @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>;
+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>;
+export declare function recurs(n: number): Schedule.WithState<number, never, 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>;
+export declare function recurWhile<A>(f: (a: A) => boolean): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurWhileIO
  * @tsplus location "@fncts/io/Schedule/api"
@@ -222,12 +234,12 @@ export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>): Sched
  * @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>;
+export declare function recurWhileEquals<A>(value: Lazy<A>): Schedule.WithState<void, never, 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>;
+export declare function recurUntil<A>(f: (a: A) => boolean): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurUntilIO
  * @tsplus location "@fncts/io/Schedule/api"
@@ -237,7 +249,7 @@ export declare function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>): Sched
  * @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>;
+export declare function recurUntilEquals<A>(value: Lazy<A>): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus getter fncts.io.Schedule repetitions
  * @tsplus location "@fncts/io/Schedule/api"
@@ -262,32 +274,32 @@ export declare function run_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, n
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function spaced(duration: number): Schedule.WithState<number, unknown, unknown, number>;
+export declare function spaced(duration: number): 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>): Schedule.WithState<number, unknown, unknown, A>;
+export declare function succeed<A>(a: Lazy<A>): Schedule.WithState<number, never, 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>;
+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>;
+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]>;
+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): 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>;
+export declare function unfold<A>(a: Lazy<A>, f: (a: A) => A): Schedule.WithState<A, never, unknown, A>;
 /**
  * @tsplus fluent fncts.io.Schedule untilInput
  * @tsplus location "@fncts/io/Schedule/api"
@@ -297,7 +309,7 @@ export declare function untilInput_<S, R, I, O>(self: Schedule.WithState<S, R, I
  * @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>;
+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"
@@ -307,12 +319,12 @@ export declare function untilOutput_<S, R, I, O>(self: Schedule.WithState<S, R,
  * @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>;
+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>;
+export declare function upTo(duration: number): Schedule.WithState<Maybe<number>, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule whileInput
  * @tsplus location "@fncts/io/Schedule/api"
@@ -322,7 +334,7 @@ export declare function whileInput_<S, R, I, O>(self: Schedule.WithState<S, R, I
  * @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>;
+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"
@@ -332,29 +344,29 @@ export declare function whileOutput_<S, R, I, O>(self: Schedule.WithState<S, R,
  * @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>;
+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>;
+export declare function windowed(interval: number): Schedule.WithState<readonly [Maybe<number>, number], never, 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]>;
+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>;
+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>;
+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>;
+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>;

package/Schedule/definition.d.ts

@@ -32,7 +32,7 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export declare abstract class Schedule<Env, In, Out> {
-    readonly _Env: (_: Env) => void;
+    readonly _Env: () => Env;
     readonly _In: (_: In) => void;
     readonly _Out: () => Out;
     readonly _State: unknown;

package/Scope/Finalizer/definition.d.ts

@@ -3,14 +3,14 @@ import { Newtype } from "@fncts/base/data/Newtype";
 import { Exit } from "@fncts/base/data/Exit";
 import { IO } from "@fncts/io/IO/definition";
 interface FinalizerN extends HKT {
-    readonly [HKT.T]: Finalizer;
+    readonly type: Finalizer;
 }
 /**
  * @tsplus type fncts.io.Managed.Finalizer
  */
 export interface Finalizer extends Newtype<{
     readonly Finalizer: unique symbol;
-}, (exit: Exit<any, any>) => IO<unknown, never, any>> {
+}, (exit: Exit<any, any>) => IO<never, never, any>> {
 }
 /**
  * @tsplus type fncts.io.Managed.FinalizerOps

package/Scope/ReleaseMap/api.d.ts

@@ -12,7 +12,7 @@ export declare function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer)
  * @tsplus fluent fncts.io.Scope.ReleaseMap release
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any>;
+export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<never, never, any>;
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap add
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"

package/Scope/ReleaseMap/definition.d.ts

@@ -20,7 +20,7 @@ export declare class Running {
 }
 export declare type State = Exited | Running;
 interface ReleaseMapN extends HKT {
-    readonly [HKT.T]: ReleaseMap;
+    readonly type: ReleaseMap;
 }
 /**
  * @tsplus type fncts.io.Scope.ReleaseMap

package/Scope/api.d.ts

@@ -1,7 +1,6 @@
 import { Scope } from "@fncts/io/Scope/definition";
 import { Lazy } from "@fncts/base/data/function";
 import { UIO, IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { Exit } from "@fncts/base/data/Exit";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
@@ -15,7 +14,7 @@ export declare function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>): U
  * @tsplus static fncts.io.ScopeOps addFinalizer
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Has<Scope>, never, void>;
+export declare function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Scope, never, void>;
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -26,7 +25,7 @@ export declare const concurrent: UIO<Scope.Closeable>;
  * @tsplus fluent fncts.io.Scope extend
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R, E, A>>): IO<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus static fncts.io.ScopeOps global
  * @tsplus location "@fncts/io/Scope/api"
@@ -58,4 +57,4 @@ export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy): Sc
  * @tsplus fluent 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 & Has<Scope>, E, A>>): IO<R, E, A>;
+export declare function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R, E, A>>): IO<Exclude<R, Scope>, E, A>;

package/ScopedRef/api.d.ts

@@ -1,5 +1,4 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
 import { Ref } from "@fncts/io/Ref";
@@ -8,4 +7,4 @@ import { Exit } from "@fncts/base/data/Exit";
  * @tsplus static fncts.io.ScopedRefOps fromAcquire
  * @tsplus location "@fncts/io/ScopedRef/api"
  */
-export declare function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R & Has<Scope>, E, ScopedRef<A>>;
+export declare function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, ScopedRef<A>>;

package/ScopedRef/definition.d.ts

@@ -1,5 +1,4 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 export declare const ScopedRefTypeId: unique symbol;
 export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
@@ -9,6 +8,6 @@ export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
  */
 export declare abstract class ScopedRef<A> {
     readonly _typeId: ScopedRefTypeId;
-    abstract set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+    abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
     abstract get: UIO<A>;
 }