@fncts/io 0.0.38 → 0.0.40

package/Ref/api/collect.d.ts

@@ -8,4 +8,4 @@ import type { PRef } from "../definition.js";
  * @tsplus pipeable fncts.io.Ref.Synchronized collect
  * @tsplus location "@fncts/io/Ref/api/collect"
  */
-export declare function collect<B, C>(pf: (_: B) => Maybe<C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EB>, A, C>;
+export declare function collect<B, C>(pf: (_: B) => Maybe<C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, Maybe<EB>, A, C>;

package/Ref/api/filter.d.ts

@@ -9,7 +9,7 @@ import type { PRef } from "../definition.js";
  * @tsplus pipeable fncts.io.Ref.Synchronized filterInput
  * @tsplus location "@fncts/io/Ref/api/filter"
  */
-export declare function filterInput<A, A1 extends A>(p: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, import("@fncts/base/data/Maybe.js").Maybe<EA>, EB, A1, B>;
+export declare function filterInput<A, A1 extends A>(p: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, Maybe<EA>, EB, A1, B>;
 /**
  * Filters the `get` value of the `Ref` with the specified predicate,
  * returning a `Ref` with a `get` value that succeeds if the predicate is

package/Ref/api/modify.d.ts

@@ -9,7 +9,7 @@ import type { PRef } from "../definition.js";
  * @tsplus pipeable fncts.io.Ref.Synchronized modify
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, B>;
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, B>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * which computes a return value for the modification if the function is
@@ -19,7 +19,7 @@ export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace
  * @tsplus pipeable fncts.io.Ref.Synchronized modifyJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, B>;
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, B>;
 /**
  * Atomically writes the specified value to the `Ref`, returning the value
  * immediately before modification.
@@ -27,7 +27,7 @@ export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B,
  * @tsplus pipeable fncts.io.Ref.Synchronized getAndSet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function, returning
  * the value immediately before modification.
@@ -35,7 +35,7 @@ export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <RA, RB, EA,
  * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdate
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * returning the value immediately before modification. If the function is
@@ -44,14 +44,14 @@ export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function.
  * @tsplus pipeable fncts.io.Ref update
  * @tsplus pipeable fncts.io.Ref.Synchronized update
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, void>;
 /**
  * Atomically modifies the `Ref` with the specified function and returns
  * the updated value.
@@ -67,7 +67,7 @@ export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.Ref.Synchronized updateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, void>;
 /**
  * Atomically modifies the `Ref` with the specified partial function. If
  * the function is undefined on the current value it returns the old value
@@ -76,4 +76,4 @@ export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => IO<RA | RB, EA | EB, A>;

package/Ref/api/set.d.ts

@@ -7,4 +7,4 @@ import type { PRef } from "../definition.js";
  * @tsplus pipeable fncts.io.Ref.Synchronized set
  * @tsplus location "@fncts/io/Ref/api/set"
  */
-export declare function set<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => import("../../IO.js").IO<RA, EA, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => IO<RA, EA, void>;

package/Ref/api.d.ts

@@ -1,12 +1,12 @@
 import type { PRef } from "./definition.js";
-export * from "./api/collect.js";
-export * from "./api/dimap.js";
-export * from "./api/filter.js";
-export * from "./api/get.js";
-export * from "./api/match.js";
-export * from "./api/matchAll.js";
-export * from "./api/modify.js";
 export * from "./api/set.js";
+export * from "./api/modify.js";
+export * from "./api/matchAll.js";
+export * from "./api/match.js";
+export * from "./api/get.js";
+export * from "./api/filter.js";
+export * from "./api/dimap.js";
+export * from "./api/collect.js";
 /**
  * Returns a read only view of the `Ref`.
  * @tsplus getter fncts.io.Ref readOnly

package/Ref.d.ts

@@ -1,10 +1,10 @@
-export * from "./Ref/api.js";
-export * from "./Ref/Atomic.js";
-export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
-export * from "./Ref/Derived.js";
-export * from "./Ref/DerivedAll.js";
+export * from "./Ref/constructors.js";
+export * from "./Ref/api.js";
 export * from "./Ref/Synchronized.js";
-export * from "./Ref/Synchronized/api.js";
-export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/DerivedAll.js";
+export * from "./Ref/Derived.js";
+export * from "./Ref/Atomic.js";
 export * from "./Ref/Synchronized/definition.js";
+export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/Synchronized/api.js";

package/RefSubject/api.d.ts

@@ -26,7 +26,7 @@ export declare function get<R, E, A, B>(self: RefSubject<R, E, A, B>, __tsplusTr
  * @tsplus pipeable fncts.io.Push.RefSubject set
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function set<A>(a: A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => import("../IO.js").IO<R, never, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => IO<R, never, void>;
 /**
  * Transforms both the `set` and `get` values of the `Ref` with the
  * specified functions.
@@ -53,7 +53,7 @@ export declare function map<B, C>(f: (_: B) => C, __tsplusTrace?: string): <R, E
  * @tsplus pipeable fncts.io.Push.RefSubject modify
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, B>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * which computes a return value for the modification if the function is
@@ -62,21 +62,21 @@ export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace
  * @tsplus pipeable fncts.io.Push.RefSubject modifyJust
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, B>;
 /**
  * Atomically writes the specified value to the `Ref`, returning the value
  * immediately before modification.
  * @tsplus pipeable fncts.io.Push.RefSubject getAndSet
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, A>;
 /**
  * Atomically modifies the `Ref` with the specified function, returning
  * the value immediately before modification.
  * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdate
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, E, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, E, A>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * returning the value immediately before modification. If the function is
@@ -84,13 +84,13 @@ export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdateJust
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, A>;
 /**
  * Atomically modifies the `Ref` with the specified function.
  * @tsplus pipeable fncts.io.Push.RefSubject update
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, void>;
 /**
  * Atomically modifies the `Ref` with the specified function and returns
  * the updated value.
@@ -104,7 +104,7 @@ export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.Push.RefSubject updateJust
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, void>;
 /**
  * Atomically modifies the `Ref` with the specified partial function. If
  * the function is undefined on the current value it returns the old value
@@ -112,7 +112,7 @@ export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Push.RefSubject updateJustAndGet
  * @tsplus location "@fncts/io/RefSubject/api"
  */
-export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => IO<R, never, A>;
 /**
  * @tsplus getter fncts.io.Push.RefSubject unsafeGet
  * @tsplus location "@fncts/io/RefSubject/api"

package/RefSubject/definition.d.ts

@@ -45,6 +45,8 @@ export declare abstract class RefSubjectInternal<R, E, A, B> implements Readable
     abstract get unsafeGet(): B;
 }
 /**
+ * @tsplus static fncts.io.Push.RefSubjectOps concrete
  * @tsplus macro remove
+ * @tsplus location "@fncts/io/RefSubject/definition"
  */
 export declare function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B>;

package/RefSubject.d.ts

@@ -1,3 +1,3 @@
+export * from "./RefSubject/definition.js";
 export * from "./RefSubject/api.js";
 export * from "./RefSubject/Atomic.js";
-export * from "./RefSubject/definition.js";

package/Reloadable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Reloadable/api.js";
-export * from "./Reloadable/constructors.js";
 export * from "./Reloadable/definition.js";
+export * from "./Reloadable/constructors.js";
+export * from "./Reloadable/api.js";

package/RuntimeFlags.d.ts

@@ -1,2 +1,2 @@
-export * from "./RuntimeFlags/Patch.js";
 export * from "./RuntimeFlags/RuntimeFlags.js";
+export * from "./RuntimeFlags/Patch.js";

package/STM/api/core-api.d.ts

@@ -4,14 +4,14 @@ import { STM } from "@fncts/io/STM/definition";
  * @tsplus pipeable fncts.io.STM catchAll
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function catchAll<E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>, __tsplusTrace?: string): <R, A>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E1, B | A>;
+export declare function catchAll<E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>, __tsplusTrace?: string): <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1, A | B>;
 /**
  * Feeds the value produced by this effect to the specified function,
  * and then runs the returned effect as well to produce its results.
  * @tsplus pipeable fncts.io.STM flatMap
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E1 | E, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E | E1, B>;
 /**
  * Executes the specified finalization transaction whether or
  * not this effect succeeds. Note that as with all STM transactions,
@@ -19,17 +19,17 @@ export declare function flatMap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsp
  * @tsplus pipeable fncts.io.STM ensuring
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function ensuring<R1, B>(finalizer: STM<R1, never, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E, A>;
+export declare function ensuring<R1, B>(finalizer: STM<R1, never, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R | R1, E, A>;
 /**
  * Maps the value produced by the effect.
  * @tsplus pipeable fncts.io.STM map
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R, E, B>;
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
 /**
  * Effectfully folds over the `STM` effect, handling both failure and
  * success.
  * @tsplus pipeable fncts.io.STM matchSTM
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function matchSTM<E, A, R1, E1, B, R2, E2, C>(g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R2 | R, E1 | E2, B | C>;
+export declare function matchSTM<E, A, R1, E1, B, R2, E2, C>(g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, B | C>;

package/STM/api.d.ts

@@ -76,7 +76,7 @@ export declare function catchWith<N extends keyof E, K extends E[N] & string, E,
  * @tsplus pipeable fncts.io.STM catchJust
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catchJust<E, R1, E1, B>(f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E | E1, B | A>;
+export declare function catchJust<E, R1, E1, B>(f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E | E1, A | B>;
 /**
  * Recovers from specified error.
  * @tsplus pipeable fncts.io.STM catchTag
@@ -86,9 +86,9 @@ export declare function catchTag<K extends E["_tag"] & string, E extends {
     _tag: string;
 }, R1, E1, A1>(k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => STM<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E1 | Exclude<E, {
+}>) => STM<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R | R1, Exclude<E, {
     _tag: K;
-}>, A1 | A>;
+}> | E1, A | A1>;
 /**
  * Creates a composite effect that represents this effect followed by another
  * one that may depend on the error produced by this one.
@@ -113,14 +113,14 @@ export declare function commitEither<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?:
  * @tsplus pipeable fncts.io.STM continueOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFail<E1, A, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R, E1 | E, A2>;
+export declare function continueOrFail<E1, A, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R, E | E1, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * continue with the returned value.
  * @tsplus pipeable fncts.io.STM continueOrFailSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFailSTM<E1, A, R2, E2, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E1 | E2 | E, A2>;
+export declare function continueOrFailSTM<E1, A, R2, E2, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E | E1 | E2, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
@@ -134,7 +134,7 @@ export declare function continueOrRetry<A, A2>(pf: (a: A) => Maybe<A2>, __tsplus
  * @tsplus pipeable fncts.io.STM continueOrRetrySTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetrySTM<A, R2, E2, A2>(pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E2 | E, A2>;
+export declare function continueOrRetrySTM<A, R2, E2, A2>(pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E | E2, A2>;
 /**
  * Suspends creation of the specified transaction lazily.
  * @tsplus static fncts.io.STMOps defer
@@ -165,7 +165,7 @@ export declare function filterMap<A, B>(f: (a: A) => Maybe<B>, __tsplusTrace?: s
  * @tsplus pipeable fncts.io.STM filterMapSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMapSTM<A, R1, E1, B>(f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, B>;
+export declare function filterMapSTM<A, R1, E1, B>(f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R | R1, E | E1, B>;
 /**
  * Applies `or` if the predicate fails.
  * @tsplus pipeable fncts.io.STM filterOrElse
@@ -198,7 +198,7 @@ export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>,
  * @tsplus pipeable fncts.io.STM flattenErrorOption
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function flattenErrorOption<E2>(def: Lazy<E2>, __tsplusTrace?: string): <R, E, A>(stm: STM<R, import("@fncts/base/data/Maybe.js").Maybe<E>, A>) => STM<R, E2 | E, A>;
+export declare function flattenErrorOption<E2>(def: Lazy<E2>, __tsplusTrace?: string): <R, E, A>(stm: STM<R, Maybe<E>, A>) => STM<R, E | E2, A>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns a transactional effect that produces a new `ReadonlyArray<B>`.
@@ -284,7 +284,7 @@ export declare function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusT
  * @tsplus pipeable fncts.io.STM leftOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string): <R, E, B>(stm: STM<R, E, import("@fncts/base/data/Either.js").Either<B, C>>) => STM<R, E1 | E, B>;
+export declare function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string): <R, E, B>(stm: STM<R, E, Either<B, C>>) => STM<R, E | E1, B>;
 /**
  * Maps from one error type to another.
  * @tsplus pipeable fncts.io.STM mapError
@@ -346,7 +346,7 @@ export declare function swapWith<R, E, A, R2, E2, A2>(f: (stm: STM<R, A, E>) =>
  * @tsplus pipeable fncts.io.STM tap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function tap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
+export declare function tap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R1 | R, E | E1, A>;
 /**
  * Returns an effect with the value on the left part.
  * @tsplus static fncts.io.STMOps toLeft
@@ -365,16 +365,16 @@ export declare const unit: STM<never, never, void>;
  * @tsplus pipeable fncts.io.STM zipWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, C>;
+export declare function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R | R1, E | E1, C>;
 /**
  * @tsplus pipeable fncts.io.STM zipLeft
  * @tsplus opipeable-operator fncts.io.STM <
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipLeft<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.STM zipRight
  * @tsplus pipeable-operator fncts.io.STM >
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipRight<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, B>;
+export declare function zipRight<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R | R1, E | E1, B>;

package/STM.d.ts

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