@fncts/io 0.0.39 → 0.0.41

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";

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