@fncts/io 0.0.38 → 0.0.40

package/Layer/MemoMap.d.ts

@@ -19,7 +19,7 @@ export declare class MemoMap {
      * returns it. Otherwise, obtains the dependency, stores it in the memo map,
      * and adds a finalizer to the outer `Managed`.
      */
-    getOrElseMemoize: <R, E, A>(scope: Scope, layer: import("@fncts/io/Layer/definition").Layer<R, E, A>, __tsplusTrace?: string) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
+    getOrElseMemoize: <R, E, A>(scope: Scope, layer: Layer<R, E, A>, __tsplusTrace?: string) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
 }
 /**
  * @tsplus fluent fncts.io.Layer isFresh
@@ -36,9 +36,9 @@ export declare function build<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Layer build
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function build_(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
+export declare function build_(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: Layer<R, E, A>) => IO<R, E, Environment<A>>;
 /**
  * @tsplus pipeable fncts.io.Layer scope
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function scope(scope: Scope, __tsplusTrace?: string): <R, E, A>(layer: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<never, never, (_: MemoMap) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>>;
+export declare function scope(scope: Scope, __tsplusTrace?: string): <R, E, A>(layer: Layer<R, E, A>) => import("../IO").IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>>;

package/Layer/api.d.ts

@@ -6,12 +6,13 @@ import { IO, URIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
 import type { Spreadable } from "@fncts/base/types";
+import type { Runtime } from "@fncts/io/IO";
 import { Layer } from "@fncts/io/Layer/definition";
 /**
  * @tsplus pipeable fncts.io.Layer and
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1 | ROut>;
+export declare function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1, E | E1, ROut | ROut1>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
@@ -19,7 +20,7 @@ export declare function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsp
  * @tsplus pipeable fncts.io.Layer andTo
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function andTo<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn1, ROut>, E1 | E, ROut1 | ROut>;
+export declare function andTo<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
@@ -32,17 +33,17 @@ export declare function andUsing<RIn, E, ROut>(that: Layer<RIn, E, ROut>, __tspl
  * @tsplus pipeable fncts.io.Layer catchAll
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function catchAll<E, RIn1, E1, ROut1>(f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1, ROut1 | ROut>;
+export declare function catchAll<E, RIn1, E1, ROut1>(f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1, E1, ROut | ROut1>;
 /**
  * @tsplus pipeable fncts.io.Layer flatMap
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function flatMap<ROut, RIn1, E1, ROut1>(f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1>;
+export declare function flatMap<ROut, RIn1, E1, ROut1>(f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1, E | E1, ROut1>;
 /**
  * @tsplus pipeable fncts.io.Layer compose
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function compose<ROut, E1, ROut1>(that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn, E1 | E, ROut1>;
+export declare function compose<ROut, E1, ROut1>(that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn, E | E1, ROut1>;
 /**
  * @tsplus static fncts.io.LayerOps environment
  * @tsplus location "@fncts/io/Layer/api"
@@ -120,12 +121,12 @@ export declare function haltNow(defect: unknown, __tsplusTrace?: string): Layer<
  * @tsplus pipeable fncts.io.Layer matchCauseLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchCauseLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn2 | RIn, E1 | E2, ROut1 | ROut2>;
+export declare function matchCauseLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
 /**
  * @tsplus pipeable fncts.io.Layer matchLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn2 | RIn, E1 | E2, ROut1 | ROut2>;
+export declare function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
 /**
  * @tsplus pipeable fncts.io.Layer map
  * @tsplus location "@fncts/io/Layer/api"
@@ -145,7 +146,7 @@ export declare function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplu
  * @tsplus pipeable fncts.io.Layer orElse
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function orElse<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1 | ROut>;
+export declare function orElse<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1, E | E1, ROut | ROut1>;
 /**
  * @tsplus getter fncts.io.Layer orHalt
  * @tsplus location "@fncts/io/Layer/api"
@@ -160,7 +161,7 @@ export declare function passthrough<RIn extends Spreadable, E, ROut extends Spre
  * @tsplus pipeable fncts.io.Layer retry
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function retry<E, S, RIn1>(schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E, ROut>;
+export declare function retry<E, S, RIn1>(schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | RIn1, E, ROut>;
 /**
  * @tsplus static fncts.io.LayerOps scoped
  * @tsplus location "@fncts/io/Layer/api"
@@ -206,3 +207,8 @@ export declare function to<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>): <RIn,
  * @tsplus location "@fncts/io/Layer/api"
  */
 export declare function using<RIn, E, ROut>(that: Layer<RIn, E, ROut>): <RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
+/**
+ * @tsplus getter fncts.io.Layer toRuntime
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function toRuntime<RIn, E, ROut>(self: Layer<RIn, E, ROut>): IO<RIn | Scope, E, Runtime<ROut>>;

package/Layer.d.ts

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

package/Logger/api.d.ts

@@ -6,9 +6,9 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus pipeable fncts.io.Logger filterLogLevel
  * @tsplus location "@fncts/io/Logger/api"
  */
-export declare function filterLogLevel(p: Predicate<LogLevel>): <Message, Output>(self: import("./definition").Logger<Message, Output>) => import("./definition").Logger<Message, import("@fncts/base/data/Maybe").Maybe<Output>>;
+export declare function filterLogLevel(p: Predicate<LogLevel>): <Message, Output>(self: Logger<Message, Output>) => Logger<Message, Maybe<Output>>;
 /**
  * @tsplus pipeable fncts.io.Logger map
  * @tsplus location "@fncts/io/Logger/api"
  */
-export declare function map<Output, B>(f: (_: Output) => B): <Message>(self: import("./definition").Logger<Message, Output>) => import("./definition").Logger<Message, B>;
+export declare function map<Output, B>(f: (_: Output) => B): <Message>(self: Logger<Message, Output>) => Logger<Message, B>;

package/Logger.d.ts

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

package/MVar.d.ts

@@ -1,2 +1,2 @@
-export * from "./MVar/api.js";
 export * from "./MVar/definition.js";
+export * from "./MVar/api.js";

package/Push/api.d.ts

@@ -45,7 +45,7 @@ export declare function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>)
  * @tsplus pipeable fncts.io.PushOps combineLatestWith
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function combineLatestWith<A, R1, E1, B, C>(that: Push<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, C>;
+export declare function combineLatestWith<A, R1, E1, B, C>(that: Push<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, C>;
 /**
  * @tsplus pipeable fncts.io.Push debounce
  * @tsplus location "@fncts/io/Push/api"
@@ -60,22 +60,22 @@ export declare function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A>
  * @tsplus pipeable fncts.io.Push exhaustMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function exhaustMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function exhaustMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push exhaustMapIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function exhaustMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function exhaustMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push filterIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filterIO<A, R1, E1>(predicate: (a: A) => IO<R1, E1, boolean>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, A>;
+export declare function filterIO<A, R1, E1>(predicate: (a: A) => IO<R1, E1, boolean>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Push filterMapIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push filter
  * @tsplus location "@fncts/io/Push/api"
@@ -91,22 +91,22 @@ export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <R, E>(self: Pus
  * @tsplus pipeable fncts.io.Push flatMapConcurrentBounded
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMapConcurrentBounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, concurrency: number): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function flatMapConcurrentBounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, concurrency: number): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push flatMapConcurrentUnbounded
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMapConcurrentUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function flatMapConcurrentUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push flatMapConcurrent
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMapConcurrent<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function flatMapConcurrent<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push flatMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus getter fncts.io.Push flatten
  * @tsplus location "@fncts/io/Push/api"
@@ -185,12 +185,12 @@ export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>):
  * @tsplus pipeable fncts.io.Push mapIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push merge
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function merge<R1, E1, B>(that: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B | A>;
+export declare function merge<R1, E1, B>(that: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E | E1, A | B>;
 /**
  * @tsplus static fncts.io.PushOps mergeAll
  * @tsplus location "@fncts/io/Push/api"
@@ -201,7 +201,7 @@ export declare function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Pus
  * @tsplus pipeable fncts.io.Push observe
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function observe<A, R1, E1>(f: (a: A) => IO<R1, E1, void>, __tsplusTrace?: string): <R, E>(self: Push<R, E, A>) => IO<import("../Scope.js").Scope | R1 | R, E1 | E, void>;
+export declare function observe<A, R1, E1>(f: (a: A) => IO<R1, E1, void>, __tsplusTrace?: string): <R, E>(self: Push<R, E, A>) => IO<R | R1 | Scope, E | E1, void>;
 /**
  * @tsplus static fncts.io.PushOps repeatIOMaybe
  * @tsplus location "@fncts/io/Push/api"
@@ -231,22 +231,22 @@ export declare function succeed<A>(value: Lazy<A>): Push<never, never, A>;
  * @tsplus pipeable fncts.io.Push switchMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function switchMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function switchMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push switchMapIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function switchMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+export declare function switchMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Push tap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, A>;
+export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Push transform
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function transform<R1 = never>(f: <R, E, A>(io: IO<R, E, A>) => IO<R | R1, E, A>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E, A>;
+export declare function transform<R1 = never>(f: <R, E, A>(io: IO<R, E, A>) => IO<R | R1, E, A>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E, A>;
 /**
  * @tsplus static fncts.io.PushOps unfold
  * @tsplus location "@fncts/io/Push/api"
@@ -261,12 +261,12 @@ export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<r
  * @tsplus pipeable fncts.io.Push untilFuture
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function untilFuture<E1, B>(future: Future<E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E1 | E, A>;
+export declare function untilFuture<E1, B>(future: Future<E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Push untilPush
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function untilPush<R1, E1, B>(signal: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, A>;
+export declare function untilPush<R1, E1, B>(signal: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
 /**
  * @tsplus static fncts.io.PushOps unwrap
  * @tsplus location "@fncts/io/Push/api"

package/Push.d.ts

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

package/Queue/api/dimapIO.d.ts

@@ -10,38 +10,38 @@ import { DequeueTypeId, EnqueueTypeId, QueueTypeId, QueueVariance } from "@fncts
  * @tsplus pipeable fncts.io.Queue dimap
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
+export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
 /**
  * Transforms elements enqueued into and dequeued from this queue with the
  * specified effectual functions.
  * @tsplus pipeable fncts.io.Queue dimapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function dimapIO_<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+export declare function dimapIO_<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  * @tsplus pipeable fncts.io.Queue contramapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function contramapInputIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RC | RA, RB, EC | EA, EB, C, B>;
+export declare function contramapInputIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA | RC, RB, EA | EC, EB, C, B>;
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  * @tsplus pipeable fncts.io.Queue contramap
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function contramapInput<A, C>(f: (c: C) => A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, B>;
+export declare function contramapInput<A, C>(f: (c: C) => A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, RB, EA, EB, C, B>;
 /**
  * Transforms elements dequeued from this queue with an effectful function.
  * @tsplus pipeable fncts.io.Queue mapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function mapIO<B, R2, E2, C>(f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, R2 | RB, EA, E2 | EB, A, C>;
+export declare function mapIO<B, R2, E2, C>(f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, R2 | RB, EA, EB | E2, A, C>;
 /**
  * Transforms elements dequeued from this queue with a function.
  * @tsplus pipeable fncts.io.Queue map
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, C>;
+export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, RB, EA, EB, A, C>;
 declare class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<RA | RC, RB, EA | EC, EB, C, B> {
     readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>;
     readonly f: (c: C) => IO<RC, EC, A>;

package/Queue/api/filterInputIO.d.ts

@@ -9,17 +9,17 @@ import type { PEnqueue } from "@fncts/io/Queue/definition";
  * @tsplus pipeable fncts.io.Queue filterInputIO
  * @tsplus location "@fncts/io/Queue/api/filterInputIO"
  */
-export declare function filterInputIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<R2 | RA, RB, E2 | EA, EB, A1, B>;
+export declare function filterInputIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA | R2, RB, EA | E2, EB, A1, B>;
 /**
  * Applies a filter to elements enqueued into this queue. Elements that do not
  * pass the filter will be immediately dropped.
  * @tsplus pipeable fncts.io.Queue filterInput
  * @tsplus location "@fncts/io/Queue/api/filterInputIO"
  */
-export declare function filterInput<A, A1 extends A>(f: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A1, B>;
+export declare function filterInput<A, A1 extends A>(f: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, RB, EA, EB, A1, B>;
 /**
  * Like `filterInput`, but uses an effectful function to filter the elements.
  * @tsplus pipeable fncts.io.Queue.Enqueue filterInputIO
  * @tsplus location "@fncts/io/Queue/api/filterInputIO"
  */
-export declare function filterInputEnqueueIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => PEnqueue<R2 | RA, RB, E2 | EA, EB, A1, B>;
+export declare function filterInputEnqueueIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => PEnqueue<RA | R2, RB, EA | E2, EB, A1, B>;

package/Queue/api/filterOutputIO.d.ts

@@ -7,14 +7,14 @@ import type { PDequeue } from "@fncts/io/Queue/definition";
  * @tsplus pipeable fncts.io.Queue filterOutputIO
  * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
  */
-export declare function filterOutputIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB1 | RB, EA, EB1 | EB, A, B>;
+export declare function filterOutputIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, RB | RB1, EA, EB | EB1, A, B>;
 /**
  * @tsplus pipeable fncts.io.Queue filterOutput
  * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
  */
-export declare function filterOutput<B>(p: Predicate<B>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>;
+export declare function filterOutput<B>(p: Predicate<B>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA, RB, EA, EB, A, B>;
 /**
  * @tsplus pipeable fncts.io.Queue.Dequeue filterOutputIO
  * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
  */
-export declare function filterOutputDequeueIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PDequeue<RA, RB, EA, EB, A, B>) => PDequeue<RA, RB1 | RB, EA, EB1 | EB, A, B>;
+export declare function filterOutputDequeueIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PDequeue<RA, RB, EA, EB, A, B>) => PDequeue<RA, RB | RB1, EA, EB | EB1, A, B>;

package/Queue/api/operations.d.ts

@@ -26,7 +26,7 @@ export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA,
  * @tsplus pipeable fncts.io.Queue offer
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function offer<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RA, EA, boolean>;
+export declare function offer<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => IO<RA, EA, boolean>;
 /**
  * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
  * If the queue has reached capacity, then
@@ -77,7 +77,7 @@ export declare function take<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, E
 export declare function takeAll<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
 /**
  * Takes up to max number of values in the queue.
- * @tsplus pipeable fncts.io.Queue takeAllUpTo
+ * @tsplus pipeable fncts.io.Queue takeUpTo
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function takeAllUpTo(n: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
+export declare function takeUpTo(n: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/takeBetween.d.ts

@@ -8,4 +8,4 @@ import type { PDequeue } from "@fncts/io/Queue/definition";
  * @tsplus pipeable fncts.io.Queue takeBetween
  * @tsplus location "@fncts/io/Queue/api/takeBetween"
  */
-export declare function takeBetween(min: number, max: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
+export declare function takeBetween(min: number, max: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>) => IO<RB, EB, Conc<B>>;

package/Queue/api/takeN.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue } from "@fncts/io/Queue";
+/**
+ * @tsplus pipeable fncts.io.Queue takeN
+ * @tsplus location "@fncts/io/Queue/api/takeN"
+ */
+export declare function takeN(n: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>) => IO<RB, EB, Conc<B>>;

package/Queue/api/zipWithIO.d.ts

@@ -12,16 +12,16 @@ import { PQueue } from "@fncts/io/Queue/definition";
  * @tsplus pipeable fncts.io.Queue zipWithIO
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWithIO<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3, E3, D>(fb: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (b: B, c: B1) => IO<R3, E3, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(fa: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | R3 | RB, EA1 | EA, EB1 | E3 | EB, A1, D>;
+export declare function zipWithIO<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3, E3, D>(fb: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (b: B, c: B1) => IO<R3, E3, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(fa: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D>;
 /**
  * Like `zipWithIO`, but uses a pure function.
  * @tsplus pipeable fncts.io.Queue zipWith
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWith<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, C>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (a: B, b: B1) => C, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, C>;
+export declare function zipWith<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, C>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (a: B, b: B1) => C, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, C>;
 /**
  * Like `zipWith`, but tuples the elements instead of applying a function.
  * @tsplus pipeable fncts.io.Queue zip
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zip<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, readonly [B, B1]>;
+export declare function zip<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: PQueue<RA, RB, EA, EB, A, B>) => PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, B1]>;

package/Queue/api.d.ts

@@ -1,7 +1,8 @@
-export * from "./api/dimapIO.js";
-export * from "./api/filterInputIO.js";
-export * from "./api/filterOutputIO.js";
-export * from "./api/operations.js";
-export * from "./api/poll.js";
-export * from "./api/takeBetween.js";
 export * from "./api/zipWithIO.js";
+export * from "./api/takeN.js";
+export * from "./api/takeBetween.js";
+export * from "./api/poll.js";
+export * from "./api/operations.js";
+export * from "./api/filterOutputIO.js";
+export * from "./api/filterInputIO.js";
+export * from "./api/dimapIO.js";

package/Queue.d.ts

@@ -1,5 +1,5 @@
-export * from "./Queue/api.js";
-export * from "./Queue/constructors.js";
-export * from "./Queue/definition.js";
-export * from "./Queue/internal.js";
 export * from "./Queue/strategy.js";
+export * from "./Queue/internal.js";
+export * from "./Queue/definition.js";
+export * from "./Queue/constructors.js";
+export * from "./Queue/api.js";

package/Random/definition.d.ts

@@ -4,7 +4,7 @@ import type { ArrayInt } from "@fncts/base/util/rand";
  * @tsplus static fncts.io.RandomOps Tag
  * @tsplus location "@fncts/io/Random/definition"
  */
-export declare const RandomTag: import("@fncts/base/data/Tag").Tag<Random>;
+export declare const RandomTag: import("@fncts/base/data/Tag").Tag<Random, Random>;
 /**
  * @tsplus type fncts.io.Random
  * @tsplus companion fncts.io.RandomOps

package/Random.d.ts

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

package/Ref/Synchronized/api.d.ts

@@ -9,21 +9,21 @@ import type { PRef } from "../definition.js";
  * @tsplus pipeable fncts.io.Ref.Synchronized collectIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function collectIO<B, RC, EC, C>(f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, C>;
+export declare function collectIO<B, RC, EC, C>(f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C>;
 /**
  * Transforms the `set` value of the `SRef` with the specified effectual
  * function.
  * @tsplus pipeable fncts.io.Ref.Synchronized contramapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RB, EC | EA, EB, C, B>;
+export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B>;
 /**
  * Transforms both the `set` and `get` values of the `Synchronized` with the
  * specified effectual functions.
  * @tsplus pipeable fncts.io.Ref.Synchronized dimapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function dimapIO<A, B, RC, EC, RD, ED, C = A, D = B>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+export declare function dimapIO<A, B, RC, EC, RD, ED, C = A, D = B>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D>;
 /**
  * Filters the `set` value of the `SRef` with the specified effectual
  * predicate, returning a `SRef` with a `set` value that succeeds if the
@@ -39,34 +39,34 @@ export declare function filterInputIO<RA, RB, EA, EB, B, A, RC, EC, A1 extends A
  * @tsplus pipeable fncts.io.Ref.Synchronized filterOutputIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function filterOutputIO<B, RC, EC>(f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, B>;
+export declare function filterOutputIO<B, RC, EC>(f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, returning the
  * value immediately before modification.
  * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function getAndUpdateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+export declare function getAndUpdateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, EA | EB | E1, A>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, returning the
  * value immediately before modification.
  */
-export declare function getAndUpdateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+export declare function getAndUpdateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, EA | EB | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Ref.Synchronized matchIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function matchIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC, ED, C, D>;
+export declare function matchIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA | RC, RB | RD, EC, ED, C, D>;
 /**
  * @tsplus pipeable fncts.io.Ref.Synchronized matchAllIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function matchAllIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA | RB, RD | RB, EC, ED, C, D>;
+export declare function matchAllIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA | RB | RC, RB | RD, EC, ED, C, D>;
 /**
  * @tsplus pipeable fncts.io.Ref.Synchronized modifyIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, B>;
+export declare function modifyIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, EA | EB | E1, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, which computes
  * a return value for the modification if the function is defined in the current value
@@ -75,28 +75,28 @@ export declare function modifyIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, readonly
  * @tsplus pipeable fncts.io.Ref.Synchronized modifyJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyJustIO<A, R1, E1, B>(def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, B>;
+export declare function modifyJustIO<A, R1, E1, B>(def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, EA | EB | E1, B>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
+export declare function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `Synchronized` with the specified function.
  * @tsplus pipeable fncts.io.Ref.Synchronized updateIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
+export declare function updateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustAndGetIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+export declare function updateJustAndGetIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, A>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus pipeable fncts.io.Ref.Synchronized updateJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
+export declare function updateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, void>;

package/Ref/Synchronized.d.ts

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