@fncts/io 0.0.21 → 0.0.22

package/Push/api.d.ts

@@ -0,0 +1,232 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Future } from "@fncts/io/Future";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Nothing, Just, Maybe } from "@fncts/base/data/Maybe/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { _A, _E, _R } from "@fncts/base/types";
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { Emitter, Push } from "./definition.js";
+/**
+ * @tsplus pipeable fncts.io.Push as
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function as<B>(b: Lazy<B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, B>;
+/**
+ * @tsplus static fncts.io.PushOps combineLatest
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function combineLatest<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<_R<A[number]>, _E<A[number]>, {
+    [K in keyof A]: [A[K]] extends [Push<any, any, infer A>] ? A : never;
+}>;
+export declare function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, ReadonlyArray<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>;
+/**
+ * @tsplus pipeable fncts.io.Push debounce
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function debounce(duration: Lazy<Duration>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps defer
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @tsplus getter fncts.io.Push flatten
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatten<R, E, R1, E1, A>(self: Push<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromIO
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromAsyncIterable
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Push<never, never, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromIterable
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromIterable<A>(iterable: Iterable<A>): Push<never, never, A>;
+/**
+ * @tsplus getter fncts.io.Push multicast
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function multicast<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
+interface MulticastObserver<E, A> {
+    readonly emitter: Emitter<any, E, A>;
+    readonly environment: Environment<any>;
+    readonly future: Future<never, void>;
+}
+export declare class Multicast<R, E, A> implements Push<R, E, A>, Emitter<never, E, A> {
+    readonly push: Push<R, E, A>;
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+    protected observers: Array<MulticastObserver<E, A>>;
+    protected fiber: Fiber<never, unknown> | undefined;
+    constructor(push: Push<R, E, A>);
+    run<R1>(emitter: Emitter<R1, E, A>): IO<R | R1 | Scope, never, unknown>;
+    emit(value: A): import("../IO.js").IO<never, never, void>;
+    failCause(cause: Cause<E>): import("../IO.js").IO<never, never, void>;
+    get end(): import("../IO.js").IO<never, never, void>;
+    protected runEvent(value: A, observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, unknown>;
+    protected runFailCause(cause: Cause<E>, observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, boolean>;
+    protected runEnd(observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, boolean>;
+    protected cleanup(): import("../IO.js").UIO<void>;
+}
+/**
+ * @tsplus getter fncts.io.Push hold
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function hold<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
+export declare class Hold<R, E, A> extends Multicast<R, E, A> {
+    readonly push: Push<R, E, A>;
+    readonly value: AtomicReference<import("@fncts/base/data/Maybe.js").Maybe<A>>;
+    protected pendingEmitters: Array<readonly [Emitter<unknown, E, A>, Array<A>]>;
+    protected scheduledFiber: Fiber<any, any> | null;
+    constructor(push: Push<R, E, A>);
+    run<R1>(emitter: Emitter<R1, E, A>): IO<R | R1 | Scope, never, void>;
+    emit(value: A): import("../IO.js").IO<never, never, void>;
+    failCause(cause: Cause<E>): import("../IO.js").IO<never, never, void>;
+    get end(): import("../IO.js").IO<never, never, void>;
+    protected shouldScheduleFlush(): boolean;
+    protected scheduleFlush<R>(observer: Emitter<R, E, A>): import("../IO.js").IO<import("../Scope.js").Scope, never, import("../Fiber.js").Fiber.Runtime<never, void>>;
+    protected flushPending(): import("../IO.js").UIO<void>;
+    protected addValue(value: A): void;
+}
+/**
+ * @tsplus pipeable fncts.io.Push map 1
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push mapError
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.io.Push mapErrorCause
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @tsplus static fncts.io.PushOps mergeAll
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mergeAll<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<_R<A[number]>, _E<A[number]>, _A<A[number]>>;
+export declare function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps repeatIOMaybe
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function repeatIOMaybe<R, E, A>(io: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Push<R, E, A>;
+/**
+ * @tsplus getter fncts.io.Push runCollect
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function runCollect<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, Conc<A>>;
+/**
+ * @tsplus getter fncts.io.Push runDrain
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function runDrain<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, void>;
+/**
+ * @tsplus static fncts.io.PushOps scoped
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Push<Exclude<R, Scope>, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps succeed
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function succeed<A>(value: Lazy<A>): Push<never, never, A>;
+/**
+ * @tsplus pipeable fncts.io.PushOps 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>;
+/**
+ * @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>;
+/**
+ * @tsplus static fncts.io.PushOps unfold
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>): Push<never, never, A>;
+/**
+ * @tsplus static fncts.io.PushOps unfoldIO
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>): Push<R, E, A>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @tsplus static fncts.io.PushOps unwrap
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unwrap<R, E, R1, E1, A>(io: IO<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps unwrapScoped
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unwrapScoped<R, E, R1, E1, A>(self: IO<R, E, Push<R1, E1, A>>, __tsplusTrace?: string): Push<R1 | Exclude<R, Scope>, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps never
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare const never: Push<never, never, never>;
+export {};

package/Push/definition.d.ts

@@ -0,0 +1,34 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus type fncts.io.Push
+ * @tsplus companion fncts.io.PushOps
+ */
+export declare class Push<R, E, A> {
+    readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>;
+    _R: (_: never) => R;
+    _E: (_: never) => E;
+    _A: (_: never) => A;
+    constructor(run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>);
+}
+/**
+ * @tsplus type fncts.io.Push.Emitter
+ * @tsplus companion fncts.io.Push.EmitterOps
+ */
+export declare class Emitter<R, E, A> {
+    readonly emit: (value: A) => IO<R, never, unknown>;
+    readonly failCause: (cause: Cause<E>) => IO<R, never, void>;
+    readonly end: IO<R, never, void>;
+    constructor(emit: (value: A) => IO<R, never, unknown>, failCause: (cause: Cause<E>) => IO<R, never, void>, end: IO<R, never, void>);
+}
+/**
+ * @tsplus static fncts.io.PushOps __call
+ * @tsplus location "@fncts/io/Push/definition"
+ */
+export declare function makePush<R, E, A>(run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.Push.EmitterOps __call
+ * @tsplus location "@fncts/io/Push/definition"
+ */
+export declare function makeEmitter<R, E, A>(emit: (value: A) => IO<R, never, unknown>, failCause: (cause: Cause<E>) => IO<R, never, unknown>, end: IO<R, never, unknown>): Emitter<R, E, A>;

package/Push/internal.d.ts

@@ -0,0 +1,11 @@
+import { CountdownLatch } from "@fncts/io/CountdownLatch";
+import { IO } from "@fncts/io/IO/definition";
+export declare function withCountdownLatch<R, E, A, R1, E1, B>(n: number, f: (latch: CountdownLatch) => IO<R, E, A>, onEnd: IO<R1, E1, B>): IO<R | R1, E | E1, B>;
+export declare const EarlyExitTypeId: unique symbol;
+export type EarlyExitTypeId = typeof EarlyExitTypeId;
+export declare class EarlyExit {
+    readonly _typeId: EarlyExitTypeId;
+}
+export declare function isEarlyExit(u: unknown): u is EarlyExit;
+export declare const earlyExit: import("../IO").UIO<never>;
+export declare function onEarlyExit<R1, E1, B>(onEarlyExit: IO<R1, E1, B>): <R, E, A>(self: import("../IO").IO<R, E, A>) => import("../IO").IO<R1 | R, E1 | E, B | A>;

package/Push.d.ts

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

package/Queue/api/dimapIO.d.ts

@@ -0,0 +1,98 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import type { UIO } from "@fncts/io/IO";
+import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
+import { DequeueTypeId, EnqueueTypeId, QueueTypeId } from "@fncts/io/Queue/definition";
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+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>;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+    readonly [QueueTypeId]: QueueTypeId;
+    _RA: () => RA | RC;
+    _RB: () => RB;
+    _EA: () => EA | EC;
+    _EB: () => EB;
+    _A: (_: C) => void;
+    _B: () => B;
+    constructor(queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    offer(c: C): IO<RC | RA, EA | EC, boolean>;
+    offerAll(cs: Iterable<C>): IO<RC | RA, EC | EA, boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+}
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue.Enqueue contramapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramapEnqueueIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PEnqueue<RA, RB, EA, EB, A, B>) => ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C>;
+declare class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB | RC, EA, EB | EC, A, C> {
+    readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>;
+    readonly f: (b: B) => IO<RC, EC, C>;
+    readonly [DequeueTypeId]: DequeueTypeId;
+    readonly [QueueTypeId]: QueueTypeId;
+    _RA: () => RA;
+    _RB: () => RB | RC;
+    _EA: () => EA;
+    _EB: () => EB | EC;
+    _A: (_: A) => void;
+    _B: () => C;
+    constructor(queue: PDequeueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    take: IO<RB | RC, EB | EC, C>;
+    takeAll: IO<RB | RC, EB | EC, Conc<C>>;
+    takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>>;
+}
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue.Dequeue mapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function mapDequeueIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PDequeue<RA, RB, EA, EB, A, B>) => MapIO<RA, RB, EA, EB, A, B, RC, EC, C>;
+export {};

package/Queue/api/filterInputIO.d.ts

@@ -0,0 +1,25 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { PEnqueue } from "@fncts/io/Queue/definition";
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;

package/Queue/api/filterOutputIO.d.ts

@@ -0,0 +1,20 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+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>;
+/**
+ * @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>;
+/**
+ * @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>;

package/Queue/api/operations.d.ts

@@ -0,0 +1,83 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { PQueue } from "@fncts/io/Queue/definition";
+import type { PDequeue, PEnqueue, PQueueCommon } from "@fncts/io/Queue/definition";
+/**
+ * Waits until the queue is shutdown.
+ * The `IO` returned by this method will not resume until the queue has been shutdown.
+ * If the queue is already shutdown, the `IO` will resume right away.
+ * @tsplus getter fncts.io.Queue awaitShutdown
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * How many elements can hold in the queue
+ * @tsplus getter fncts.io.Queue capacity
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function capacity<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
+/**
+ * `true` if `shutdown` has been called.
+ * @tsplus getter fncts.io.Queue isShutdown
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
+/**
+ * Places one value in the queue.
+ * @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>;
+/**
+ * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
+ * If the queue has reached capacity, then
+ * the fiber performing the `offerAll` will be suspended until there is room in
+ * the queue.
+ *
+ * For Unbounded Queue:
+ * Places all values in the queue and returns true.
+ *
+ * For Sliding Queue: uses `Sliding` Strategy
+ * If there is room in the queue, it places the values otherwise it removes the old elements and
+ * enqueues the new ones. Always returns true.
+ *
+ * For Dropping Queue: uses `Dropping` Strategy,
+ * It places the values in the queue but if there is no room it will not enqueue them and return false.
+ * @tsplus pipeable fncts.io.Queue offerAll
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function offerAll<A>(as: Iterable<A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RA, EA, boolean>;
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`.
+ * Future calls to `offer*` and `take*` will be interrupted immediately.
+ * @tsplus getter fncts.io.Queue shutdown
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<void>;
+/**
+ * Retrieves the size of the queue, which is equal to the number of elements
+ * in the queue. This may be negative if fibers are suspended waiting for
+ * elements to be added to the queue.
+ * @tsplus getter fncts.io.Queue size
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function size<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<number>;
+/**
+ * Removes the oldest value in the queue. If the queue is empty, this will
+ * return a computation that resumes when an item has been added to the queue.
+ * @tsplus getter fncts.io.Queue take
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function take<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B>;
+/**
+ * Removes all the values in the queue and returns the list of the values. If the queue
+ * is empty returns empty list.
+ * @tsplus getter fncts.io.Queue takeAll
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+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 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>>;

package/Queue/api/poll.d.ts

@@ -0,0 +1,9 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { PDequeue } from "@fncts/io/Queue/definition";
+/**
+ * Take the head option of values in the queue.
+ * @tsplus getter fncts.io.Queue poll
+ * @tsplus location "@fncts/io/Queue/api/poll"
+ */
+export declare function poll<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -0,0 +1,11 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue } from "@fncts/io/Queue/definition";
+/**
+ * Takes between min and max number of values from the queue. If there
+ * is less than min items available, it'll block until the items are
+ * collected.
+ * @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>>;

package/Queue/api/zipWithIO.d.ts

@@ -0,0 +1,27 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+/**
+ * Creates a new queue from this queue and another. Offering to the composite queue
+ * will broadcast the elements to both queues; taking from the composite queue
+ * will dequeue elements from both queues and apply the function point-wise.
+ *
+ * Note that using queues with different strategies may result in surprising behavior.
+ * For example, a dropping queue and a bounded queue composed together may apply `f`
+ * to different elements.
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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]>;

package/Queue/api.d.ts

@@ -0,0 +1,7 @@
+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";

package/Queue/constructors.d.ts

@@ -1,6 +1,5 @@
 import { UIO } from "@fncts/io/IO/definition";
-import { Future } from "@fncts/io/Future";
-import { Queue } from "@fncts/io/Queue/definition";
+import type { Queue } from "@fncts/io/Queue/definition";
 /**
  * @tsplus static fncts.io.QueueOps makeSliding
  * @tsplus location "@fncts/io/Queue/constructors"