@fncts/io 0.0.21 → 0.0.23

package/Fiber/definition.d.ts

@@ -1,20 +1,25 @@
-import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { TraceElement } from "@fncts/base/data/TraceElement/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
+import type { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
+import type { UIO } from "@fncts/io/IO/definition";
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
+export declare const FiberVariance: unique symbol;
+export type FiberVariance = typeof FiberVariance;
 export declare const FiberTypeId: unique symbol;
 export type FiberTypeId = typeof FiberTypeId;
 /**
  * @tsplus type fncts.io.Fiber
  */
 export interface Fiber<E, A> {
-    readonly _typeId: FiberTypeId;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [FiberTypeId]: FiberTypeId;
+    readonly [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus type fncts.io.FiberOps
@@ -37,9 +42,11 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
      * Inherits values from all {@link FiberRef} instances into current fiber.
      * This will resume immediately.
      */
-    readonly inheritRefs: UIO<void>;
+    readonly inheritAll: UIO<void>;
     /**
-     * Interrupts the fiber as if interrupted from the specified fiber.
+     * Interrupts the fiber as if interrupted from the specified fiber. If the
+     * fiber has already exited, the returned effect will resume immediately.
+     * Otherwise, the effect will resume when the fiber exits.
      */
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     /**
@@ -60,14 +67,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
     /**
      * The location the fiber was forked from
      */
-    readonly location: TraceElement;
-    /**
-     * Evaluates the specified effect on the fiber. If this is not possible,
-     * because the fiber has already ended life, then the specified alternate
-     * effect will be executed instead.
-     */
-    readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
-    readonly evalOnIO: <R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>) => IO<R1 | R2, E1 | E2, B | C>;
+    readonly location?: string;
     /**
      * The status of the fiber.
      */
@@ -80,15 +80,17 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
 export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     readonly id: FiberId;
     readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
-    readonly inheritRefs: UIO<void>;
+    readonly inheritAll: UIO<void>;
     readonly poll: UIO<Maybe<Exit<E, A>>>;
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     readonly _tag = "SyntheticFiber";
-    readonly _typeId: FiberTypeId;
-    readonly _E: () => E;
-    readonly _A: () => A;
-    readonly await: import("../IO").UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
-    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
+    readonly [FiberTypeId]: FiberTypeId;
+    [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+    readonly await: UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
+    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritAll: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
 }
 export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
 /**
@@ -98,3 +100,8 @@ export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
  */
 export declare function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteFiber<E, A>;
 export declare function isFiber(u: unknown): u is Fiber<unknown, unknown>;
+/**
+ * @tsplus static fncts.io.FiberOps _roots
+ * @tsplus location "@fncts/io/Fiber/definition"
+ */
+export declare const _roots: IterableWeakSet<FiberRuntime<any, any>>;

package/Fiber.d.ts

@@ -1,19 +1,17 @@
 export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberContext.js";
+export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/FiberRuntime.js";
 export * from "./Fiber/api/await.js";
 export * from "./Fiber/api/awaitAll.js";
 export * from "./Fiber/api/children.js";
 export * from "./Fiber/api/collectAll.js";
-export * from "./Fiber/api/evalOn.js";
-export * from "./Fiber/api/evalOnIO.js";
 export * from "./Fiber/api/fromIO.js";
 export * from "./Fiber/api/id.js";
 export * from "./Fiber/api/inheritRefs.js";
 export * from "./Fiber/api/interrupt.js";
 export * from "./Fiber/api/interruptAll.js";
 export * from "./Fiber/api/interruptAs.js";
-export * from "./Fiber/api/interruptAsFork.js";
 export * from "./Fiber/api/interruptFork.js";
 export * from "./Fiber/api/join.js";
 export * from "./Fiber/api/joinAll.js";

package/FiberDescriptor.d.ts

@@ -1,6 +1,5 @@
-import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import type { FiberId } from "@fncts/base/data/FiberId";
-import type { FiberScope } from "@fncts/io/FiberScope";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 /**
  * A record containing information about a `Fiber`.
@@ -11,8 +10,6 @@ import type { FiberStatus } from "@fncts/io/FiberStatus";
 export declare class FiberDescriptor {
     readonly id: FiberId;
     readonly status: FiberStatus;
-    readonly interruptors: ReadonlySet<FiberId>;
-    readonly interruptStatus: InterruptStatus;
-    readonly scope: FiberScope;
-    constructor(id: FiberId, status: FiberStatus, interruptors: ReadonlySet<FiberId>, interruptStatus: InterruptStatus, scope: FiberScope);
+    readonly interruptors: HashSet<FiberId>;
+    constructor(id: FiberId, status: FiberStatus, interruptors: HashSet<FiberId>);
 }

package/FiberRef/definition.d.ts

@@ -1,5 +1,7 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+export declare const FiberRefVariance: unique symbol;
+export type FiberRefVariance = typeof FiberRefVariance;
 export declare const FiberRefTypeId: unique symbol;
 export type FiberRefTypeId = typeof FiberRefTypeId;
 /**
@@ -7,8 +9,10 @@ export type FiberRefTypeId = typeof FiberRefTypeId;
  * @tsplus companion fncts.io.FiberRefOps
  */
 export declare abstract class FiberRef<Value> {
-    readonly _typeId: FiberRefTypeId;
-    readonly _A: () => Value;
+    readonly [FiberRefTypeId]: FiberRefTypeId;
+    [FiberRefVariance]: {
+        readonly _Value: (_: Value) => Value;
+    };
     readonly _Patch: unknown;
 }
 export declare namespace FiberRef {

package/FiberRef/unsafe.d.ts

@@ -36,6 +36,11 @@ export declare function unsafeMake<A>(initial: A, fork?: (a: A) => A, join?: (a0
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
 export declare const forkScopeOverride: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>, (_: import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>) => import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps interruptedCause
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const interruptedCause: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Cause.js").Cause<never>, (_: import("@fncts/base/data/Cause.js").Cause<never>) => import("@fncts/base/data/Cause.js").Cause<never>>;
 /**
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"

package/FiberRefs/api.d.ts

@@ -3,6 +3,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs/definition";
 /**
  * @tsplus getter fncts.io.FiberRefs fiberRefs
@@ -10,6 +11,7 @@ import { FiberRefs } from "@fncts/io/FiberRefs/definition";
  */
 export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
 /**
+ * @tsplus macro identity
  * @tsplus static fncts.io.FiberRefsOps __call
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
@@ -19,3 +21,29 @@ export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<rea
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
 export declare function forkAs(childId: FiberId.Runtime): (self: FiberRefs) => FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs get
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function get<A>(self: FiberRefs, fiberRef: FiberRef<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRefs getOrDefault
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function getOrDefault<A>(self: FiberRefs, fiberRef: FiberRef<A>): A;
+/**
+ * @tsplus fluent fncts.io.FiberRefs updateAs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function updateAs<A>(self: FiberRefs, fiberId: FiberId.Runtime, fiberRef: FiberRef<A>, value: A): FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs delete
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs;
+/**
+ * @tsplus getter fncts.io.FiberRefs unFiberRefs
+ * @tsplus macro identity
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function unFiberRefs(self: FiberRefs): HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>;

package/FiberRefs/definition.d.ts

@@ -1,15 +1,22 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-export declare const FiberRefsTypeId: unique symbol;
-export type FiberRefsTypeId = typeof FiberRefsTypeId;
+export interface FiberRefsN extends HKT {
+    readonly type: FiberRefs;
+}
 /**
  * @tsplus type fncts.io.FiberRefs
- * @tsplus companion fncts.io.FiberRefsOps
  */
-export declare class FiberRefs {
-    readonly fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
-    readonly _typeId: FiberRefsTypeId;
-    constructor(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>);
+export interface FiberRefs extends Newtype<{
+    readonly FiberRefs: unique symbol;
+}, HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>> {
+}
+/**
+ * @tsplus type fncts.io.FiberRefsOps
+ */
+export interface FiberRefsOps extends NewtypeIso<FiberRefsN> {
 }
+export declare const FiberRefs: FiberRefsOps;

package/FiberScope/constructors.d.ts

@@ -1,5 +1,5 @@
 import { FiberScope } from "@fncts/io/FiberScope";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import { Global } from "@fncts/io/FiberScope/definition";
 /**
  * The global scope. Anything forked onto the global scope is not supervised,
@@ -13,4 +13,4 @@ export declare const global: Global;
  * @tsplus static fncts.io.FiberScopeOps unsafeMake
  * @tsplus location "@fncts/io/FiberScope/constructors"
  */
-export declare function unsafeMake(fiber: FiberContext<any, any>): FiberScope;
+export declare function unsafeMake(fiber: FiberRuntime<any, any>): FiberScope;

package/FiberScope/definition.d.ts

@@ -1,5 +1,8 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 /**
  * A `Scope` represents the scope of a fiber lifetime. The scope of a fiber can
  * be retrieved using IO.descriptor, and when forking fibers, you can
@@ -10,15 +13,15 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
  */
 export declare abstract class FiberScope {
     abstract fiberId: FiberId;
-    abstract unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    abstract unsafeAdd(currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Global extends FiberScope {
     get fiberId(): FiberId;
-    unsafeAdd(_child: FiberContext<any, any>): boolean;
+    unsafeAdd(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Local extends FiberScope {
     readonly fiberId: FiberId;
     private parentRef;
-    constructor(fiberId: FiberId, parentRef: WeakRef<FiberContext<unknown, unknown>>);
-    unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    constructor(fiberId: FiberId, parentRef: WeakRef<FiberRuntime<unknown, unknown>>);
+    unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }

package/FiberStatus/constructors.d.ts

@@ -1,22 +1,18 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 import type { FiberStatus } from "./definition.js";
 /**
  * @tsplus static fncts.FiberStatusOps done
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
 export declare const done: FiberStatus;
-/**
- * @tsplus static fncts.FiberStatusOps finishing
- * @tsplus location "@fncts/io/FiberStatus/constructors"
- */
-export declare function finishing(interrupting: boolean): FiberStatus;
 /**
  * @tsplus static fncts.FiberStatusOps running
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
-export declare function running(interrupting: boolean): FiberStatus;
+export declare function running(runtimeFlags: RuntimeFlags, trace?: string): FiberStatus;
 /**
  * @tsplus static fncts.FiberStatusOps suspended
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
-export declare function suspended(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string): FiberStatus;
+export declare function suspended(runtimeFlags: RuntimeFlags, blockingOn: FiberId, trace?: string): FiberStatus;

package/FiberStatus/definition.d.ts

@@ -1,56 +1,44 @@
+import { Trace } from "@fncts/base/data/Trace/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 export declare const enum FiberStatusTag {
-    Done = "Done",
-    Finishing = "Finishing",
-    Running = "Running",
-    Suspended = "Suspended"
+    Done = 0,
+    Running = 1,
+    Suspended = 2
 }
 /**
  * @tsplus companion fncts.FiberStatus.DoneOps
  */
 export declare class Done {
     readonly _tag = FiberStatusTag.Done;
-    get isInterrupting(): boolean;
-    withInterrupting(): FiberStatus;
-}
-/**
- * @tsplus companion fncts.FiberStatus.FinishingOps
- */
-export declare class Finishing {
-    readonly interrupting: boolean;
-    readonly _tag = FiberStatusTag.Finishing;
-    constructor(interrupting: boolean);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): FiberStatus;
+    readonly trace: import("@fncts/base/data/Trace.js").Trace;
+    readonly isFinished = true;
 }
 /**
  * @tsplus companion fncts.FiberStatus.RunningOps
  */
 export declare class Running {
-    readonly interrupting: boolean;
+    readonly runtimeFlags: RuntimeFlags;
+    readonly trace?: string | undefined;
     readonly _tag = FiberStatusTag.Running;
-    constructor(interrupting: boolean);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): FiberStatus;
+    constructor(runtimeFlags: RuntimeFlags, trace?: string | undefined);
+    readonly isFinished = false;
 }
 /**
  * @tsplus companion fncts.FiberStatus.SuspendedOps
  */
 export declare class Suspended {
-    readonly interrupting: boolean;
-    readonly interruptible: boolean;
-    readonly epoch: number;
+    readonly runtimeFlags: RuntimeFlags;
     readonly blockingOn: FiberId;
-    readonly asyncTrace?: string | undefined;
+    readonly trace?: string | undefined;
     readonly _tag = FiberStatusTag.Suspended;
-    constructor(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string | undefined);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): Suspended;
+    constructor(runtimeFlags: RuntimeFlags, blockingOn: FiberId, trace?: string | undefined);
+    readonly isFinished = false;
 }
 /**
  * @tsplus type fncts.FiberStatus
  */
-export type FiberStatus = Done | Finishing | Running | Suspended;
+export type FiberStatus = Done | Running | Suspended;
 /**
  * @tsplus type fncts.FiberStatusOps
  */

package/Hub/api.d.ts

@@ -0,0 +1,192 @@
+import { PHub, Hub } from "@fncts/io/Hub/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue, PEnqueue } from "@fncts/io/Queue";
+/**
+ * Waits for the hub to be shut down.
+ * @tsplus getter fncts.io.Hub awaitShutdown
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * The maximum capacity of the hub.
+ * @tsplus getter fncts.io.Hub capacity
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
+/**
+ * Transforms messages published to the hub using the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Hub contramapIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RC | RA, RB, EC | EA, EB, C, B>;
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified functions.
+ * @tsplus pipeable fncts.io.Hub dimap
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+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/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, C, D>;
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified effectual functions.
+ * @tsplus pipeable fncts.io.Hub dimapIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+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>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+/**
+ * Filters messages published to the hub using the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Hub filterInputIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function filterInputIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<R1 | RA, RB, E1 | EA, EB, A, B>;
+/**
+ * Filters messages published to the hub using the specified function.
+ * @tsplus pipeable fncts.io.Hub filterInput
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
+/**
+ * Filters messages taken from the hub using the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Hub filterOutputIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, R1 | RB, EA, E1 | EB, A, B>;
+/**
+ * Filters messages taken from the hub using the specified function.
+ * @tsplus pipeable fncts.io.Hub filterOutput
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
+/**
+ * Checks whether the hub is shut down.
+ * @tsplus getter fncts.io.Hub isShutdown
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
+/**
+ * Creates a bounded hub with the back pressure strategy. The hub will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeBounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeDropping
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeSliding
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Transforms messages taken from the hub using the specified function.
+ * @tsplus pipeable fncts.io.Hub map
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, C>;
+/**
+ * Transforms messages taken from the hub using the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Hub mapIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RC | RB, EA, EC | EB, A, C>;
+/**
+ * Publishes a message to the hub, returning whether the message was
+ * published to the hub.
+ * @tsplus pipeable fncts.io.Hub publish
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function publish<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("../IO").IO<RA, EA, boolean>;
+/**
+ * Publishes all of the specified messages to the hub, returning whether
+ * they were published to the hub.
+ * @tsplus pipeable fncts.io.Hub publishAll
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function publishAll<A>(as: Iterable<A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("../IO").IO<RA, EA, boolean>;
+/**
+ * Shuts down the hub.
+ * @tsplus getter fncts.io.Hub shutdown
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * Subscribes to receive messages from the hub. The resulting subscription
+ * can be evaluated multiple times within the scope of the managed to take a
+ * message from the hub each time.
+ * @tsplus getter fncts.io.Hub subscribe
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<Scope, never, PDequeue<RA, RB, EA, EB, A, B>>;
+/**
+ * The current number of messages in the hub.
+ * @tsplus getter fncts.io.Hub size
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number>;
+/**
+ * Views the hub as a queue that can only be written to.
+ * @tsplus getter fncts.io.Hub toQueue
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): PEnqueue<RA, RB, EA, EB, A, B>;
+/**
+ * Creates a bounded hub with the back pressure strategy. The hub will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeBounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeBounded<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeDropping
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeDropping<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeSliding
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeSliding<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps unsafeMakeUnbounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeUnbounded<A>(): Hub<A>;