@fncts/io 0.0.1

package/Layer/api.d.ts

@@ -0,0 +1,209 @@
+import { Environment } from "@fncts/base/data/Environment";
+import { Lazy } from "@fncts/base/data/function";
+import { Cause } from "@fncts/base/data/Cause";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Tag } from "@fncts/base/data/Tag";
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import type { Spreadable } from "@fncts/base/types";
+import type { Erase } from "@fncts/typelevel/Intersection";
+import { Layer } from "@fncts/io/Layer/definition";
+/**
+ * @tsplus fluent fncts.io.Layer and
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function and_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn & RIn1, E | E1, ROut & ROut1>;
+/**
+ * Feeds the output services of this layer into the input of the specified
+ * layer, resulting in a new layer with the inputs of this layer, and the
+ * outputs of both layers.
+ * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn & Erase<ROut & RIn1, ROut>, E | E1, ROut & ROut1>;
+/**
+ * Feeds the output services of this layer into the input of the specified
+ * layer, resulting in a new layer with the inputs of this layer, and the
+ * outputs of both layers.
+ * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn & Erase<ROut & RIn1, ROut>, E | E1, ROut & ROut1>;
+/**
+ * @tsplus fluent fncts.io.Layer catchAll
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (e: E) => Layer<RIn1, E1, ROut1>): Layer<RIn & RIn1, E1, ROut | ROut1>;
+/**
+ * @tsplus fluent fncts.io.Layer flatMap
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>): Layer<RIn & RIn1, E | E1, ROut1>;
+/**
+ * @tsplus fluent fncts.io.Layer compose
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function compose_<RIn, E, ROut, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>): Layer<RIn, E | E1, ROut1>;
+/**
+ * @tsplus static fncts.io.LayerOps environment
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function environment<RIn>(): Layer<RIn, never, RIn>;
+/**
+ * @tsplus static fncts.io.LayerOps fail
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fail<E>(e: Lazy<E>): Layer<unknown, E, never>;
+/**
+ * @tsplus static fncts.io.LayerOps failCause
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function failCause<E>(cause: Lazy<Cause<E>>): Layer<unknown, E, never>;
+/**
+ * @tsplus static fncts.io.LayerOps failCauseNow
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function failCauseNow<E>(cause: Cause<E>): Layer<unknown, E, never>;
+/**
+ * @tsplus static fncts.io.LayerOps failNow
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function failNow<E>(e: E): Layer<unknown, E, never>;
+/**
+ * @tsplus getter fncts.io.Layer flatten
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function flatten<RIn, E, RIn1, E1, ROut>(self: Layer<RIn, E, Has<Layer<RIn1, E1, ROut>>>, tag: Tag<Layer<RIn1, E1, ROut>>): Layer<RIn & RIn1, E | E1, ROut>;
+/**
+ * @tsplus getter fncts.io.Layer fresh
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fresh<R, E, A>(self: Layer<R, E, A>): Layer<R, E, A>;
+/**
+ * @tsplus static fncts.io.LayerOps fromFunction
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fromFunction<R, A>(f: (r: R) => A, 
+/** @tsplus implicit local */ tagR: Tag<R>, 
+/** @tsplus implicit local */ tagA: Tag<A>): Layer<Has<R>, never, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps fromFunctionIO
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fromFunctionIO<R, E, A, R1>(f: (r: R) => IO<R1, E, A>, tagR: Tag<R>, tagA: Tag<A>): Layer<R1 & Has<R>, E, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps fromIOEnvironment
+ * @tsplus static fncts.io.LayerOps __call
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fromIOEnvironment<R, E, A>(io: IO<R, E, Environment<A>>, __tsplusTrace?: string): Layer<R, E, A>;
+/**
+ * @tsplus static fncts.io.LayerOps fromIO
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>): Layer<R, E, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps fromValue
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function fromValue<A>(value: Lazy<A>, tag: Tag<A>): Layer<unknown, never, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps halt
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function halt(defect: Lazy<unknown>): Layer<unknown, never, never>;
+/**
+ * @tsplus static fncts.io.LayerOps haltNow
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function haltNow(defect: unknown): Layer<unknown, never, never>;
+/**
+ * @tsplus fluent fncts.io.Layer matchCauseLayer
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>): Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2>;
+/**
+ * @tsplus fluent fncts.io.Layer matchLayer
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>): Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2>;
+/**
+ * @tsplus fluent fncts.io.Layer map
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function map_<RIn, E, ROut, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Environment<ROut1>): Layer<RIn, E, ROut1>;
+/**
+ * @tsplus fluent fncts.io.Layer mapError
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1): Layer<RIn, E1, ROut>;
+/**
+ * @tsplus getter fncts.io.Layer memoize
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Has<Scope>, Layer<RIn, E, ROut>>;
+/**
+ * @tsplus fluent fncts.io.Layer orElse
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn & RIn1, E | E1, ROut | ROut1>;
+/**
+ * @tsplus getter fncts.io.Layer orHalt
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, never, ROut>;
+/**
+ * @tsplus getter fncts.io.Layer passthrough
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(self: Layer<RIn, E, ROut>): Layer<RIn, E, RIn & ROut>;
+/**
+ * @tsplus fluent fncts.io.Layer retry
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function retry_<RIn, E, ROut, S, RIn1>(self: Layer<RIn, E, ROut>, schedule: Schedule.WithState<S, RIn1, E, any>): Layer<RIn & RIn1, E, ROut>;
+/**
+ * @tsplus static fncts.io.LayerOps scoped
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function scoped<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, A>>, tag: Tag<A>): Layer<R, E, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps scopedEnvironment
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function scopedEnvironment<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, Environment<A>>>): Layer<R, E, A>;
+/**
+ * @tsplus static fncts.io.LayerOps service
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function service<A>(tag: Tag<A>): Layer<Has<A>, never, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps succeed
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function succeed<A>(resource: Lazy<A>, tag: Tag<A>): Layer<unknown, never, Has<A>>;
+/**
+ * @tsplus static fncts.io.LayerOps succeedEnvironment
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function succeedEnvironment<A>(a: Lazy<Environment<A>>): Layer<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.LayerOps succeedEnvironmentNow
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function succeedEnvironmentNow<A>(a: Environment<A>): Layer<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.LayerOps succeedNow
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function succeedNow<A>(resource: A, tag: Tag<A>): Layer<unknown, never, Has<A>>;
+/**
+ * @tsplus fluent fncts.io.Layer to
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function to_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn & Erase<RIn1, ROut>, E | E1, ROut1>;
+/**
+ * @tsplus fluent fncts.io.Layer using
+ * @tsplus location "@fncts/io/Layer/api"
+ */
+export declare function using_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn & Erase<RIn1, ROut>, E | E1, ROut1>;

package/Layer/definition.d.ts

@@ -0,0 +1,75 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { Environment } from "@fncts/base/data/Environment";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+export declare const LayerHash: unique symbol;
+export declare type LayerHash = typeof LayerHash;
+/**
+ * @tsplus type fncts.io.Layer
+ * @tsplus companion fncts.io.LayerOps
+ */
+export declare abstract class Layer<RIn, E, ROut> {
+    readonly _R: (_: RIn) => void;
+    readonly _E: () => E;
+    readonly _A: () => ROut;
+    [LayerHash]: PropertyKey;
+    setKey(hash: PropertyKey): this;
+}
+export declare type Concrete = Fold<any, any, any, any, any, any, any, any, any> | Fresh<any, any, any> | FromScoped<any, any, any> | Defer<any, any, any> | To<any, any, any, any, any> | ZipWith<any, any, any, any, any, any, any> | ZipWithC<any, any, any, any, any, any, any>;
+/**
+ * @tsplus fluent fncts.io.Layer concrete
+ * @tsplus location "@fncts/io/Layer/definition"
+ */
+export declare function concrete(self: Layer<any, any, any>): asserts self is Concrete;
+export declare const enum LayerTag {
+    Fold = "Fold",
+    Fresh = "Fresh",
+    Scoped = "Scoped",
+    Defer = "Defer",
+    To = "To",
+    ZipWith = "ZipWith",
+    ZipWithC = "ZipWithC"
+}
+export declare class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2> {
+    readonly self: Layer<RIn, E, ROut>;
+    readonly failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>;
+    readonly success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>;
+    readonly _tag = LayerTag.Fold;
+    constructor(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>);
+}
+export declare class Fresh<RIn, E, ROut> extends Layer<RIn, E, ROut> {
+    readonly self: Layer<RIn, E, ROut>;
+    readonly _tag = LayerTag.Fresh;
+    constructor(self: Layer<RIn, E, ROut>);
+}
+export declare class FromScoped<RIn, E, ROut> extends Layer<RIn, E, ROut> {
+    readonly self: IO<RIn & Has<Scope>, E, Environment<ROut>>;
+    readonly _tag = LayerTag.Scoped;
+    constructor(self: IO<RIn & Has<Scope>, E, Environment<ROut>>);
+}
+export declare class Defer<RIn, E, ROut> extends Layer<RIn, E, ROut> {
+    readonly self: () => Layer<RIn, E, ROut>;
+    readonly _tag = LayerTag.Defer;
+    constructor(self: () => Layer<RIn, E, ROut>);
+}
+export declare class To<RIn, E, ROut, E1, ROut1> extends Layer<RIn, E | E1, ROut1> {
+    readonly self: Layer<RIn, E, ROut>;
+    readonly that: Layer<ROut, E1, ROut1>;
+    readonly _tag = LayerTag.To;
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>);
+}
+export declare class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn & RIn1, E | E1, ROut2> {
+    readonly self: Layer<RIn, E, ROut>;
+    readonly that: Layer<RIn1, E1, ROut1>;
+    readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>;
+    readonly _tag = LayerTag.ZipWith;
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>);
+}
+export declare class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn & RIn1, E | E1, ROut2> {
+    readonly self: Layer<RIn, E, ROut>;
+    readonly that: Layer<RIn1, E1, ROut1>;
+    readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>;
+    readonly _tag = LayerTag.ZipWithC;
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>);
+}

package/Layer.d.ts

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

package/LogLevel.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @tsplus type fncts.LogLevel
+ * @tsplus companion fncts.LogLevelOps
+ */
+export declare class LogLevel {
+    readonly ordinal: number;
+    readonly label: string;
+    readonly syslog: number;
+    constructor(ordinal: number, label: string, syslog: number);
+}
+/**
+ * @tsplus fluent fncts.LogLevel lt
+ * @tsplus operator fncts.LogLevel <
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare function lt(self: LogLevel, that: LogLevel): boolean;
+/**
+ * @tsplus fluent fncts.LogLevel lte
+ * @tsplus operator fncts.LogLevel <=
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare function lte(self: LogLevel, that: LogLevel): boolean;
+/**
+ * @tsplus fluent fncts.LogLevel gte
+ * @tsplus operator fncts.LogLevel >=
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare function gte(self: LogLevel, that: LogLevel): boolean;
+/**
+ * @tsplus fluent fncts.LogLevel gt
+ * @tsplus operator fncts.LogLevel >
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare function gt(self: LogLevel, that: LogLevel): boolean;
+/**
+ * @tsplus static fncts.LogLevelOps All
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const All: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Fatal
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Fatal: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Error
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Error: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Warning
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Warning: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Info
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Info: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Debug
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Debug: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps Trace
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const Trace: LogLevel;
+/**
+ * @tsplus static fncts.LogLevelOps None
+ * @tsplus location "@fncts/io/LogLevel"
+ */
+export declare const None: LogLevel;

package/LogSpan.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @tsplus type fncts.LogSpan
+ * @tsplus companion fncts.LogSpanOps
+ */
+export declare class LogSpan {
+    readonly label: string;
+    readonly startTime: number;
+    constructor(label: string, startTime: number);
+}
+/**
+ * @tsplus fluent fncts.LogSpan render
+ * @tsplus location "@fncts/io/LogSpan"
+ */
+export declare function render(self: LogSpan, now: number): string;

package/Logger/api.d.ts

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

package/Logger/constructors.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from "@fncts/io/Logger/definition";
+/**
+ * @tsplus static fncts.io.LoggerOps defaultString
+ * @tsplus location "@fncts/io/Logger/constructors"
+ */
+export declare const defaultString: Logger<string, string>;
+/**
+ * @tsplus fncts.io.Logger none
+ */
+export declare const none: Logger<unknown, void>;

package/Logger/definition.d.ts

@@ -0,0 +1,18 @@
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { LogLevel } from "@fncts/io/LogLevel";
+import { Cause } from "@fncts/base/data/Cause";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { List } from "@fncts/base/collection/immutable/List";
+import type { LogSpan } from "@fncts/io/LogSpan";
+/**
+ * @tsplus type fncts.io.Logger
+ * @tsplus companion fncts.io.LoggerOps
+ */
+export declare class Logger<Message, Output> {
+    readonly log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<unknown>, unknown>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output;
+    readonly _Message: (_: Message) => void;
+    readonly _Output: () => Output;
+    constructor(log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<unknown>, unknown>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output);
+}

package/Logger.d.ts

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

package/Queue/api/dimapIO.d.ts

@@ -0,0 +1,41 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ * @tsplus fluent fncts.io.Queue dimap
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D): 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 fluent fncts.io.Queue dimapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PQueue<RC & RA, RD & RB, EC | EA, ED | EB, C, D>;
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus fluent fncts.io.Queue contramapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PQueue<RA & RC, RB, EA | EC, EB, C, B>;
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus fluent fncts.io.Queue contramap
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramap_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A): PQueue<RA, RB, EA, EB, C, B>;
+/**
+ * Transforms elements dequeued from this queue with an effectful function.
+ * @tsplus fluent fncts.io.Queue mapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<R2, E2, C>): PQueue<RA, R2 & RB, EA, EB | E2, A, C>;
+/**
+ * Transforms elements dequeued from this queue with a function.
+ * @tsplus fluent fncts.io.Queue map
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function map_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => C): PQueue<RA, RB, EA, EB, A, C>;

package/Queue/api/filterInputIO.d.ts

@@ -0,0 +1,32 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { QueueInternal } from "@fncts/io/Queue/definition";
+export declare class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA & R2, RB, EA | E2, EB, A1, B> {
+    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
+    readonly f: (_: A1) => IO<R2, E2, boolean>;
+    constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    offer(a: A1): IO<RA & R2, EA | E2, boolean>;
+    offerAll(as: Iterable<A1>): IO<RA & R2, EA | E2, boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    take: IO<RB, EB, B>;
+    takeAll: IO<RB, EB, Conc<B>>;
+    takeUpTo(max: number): IO<RB, EB, Conc<B>>;
+}
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ * @tsplus fluent fncts.io.Queue filterInputIO
+ * @tsplus location "@fncts/io/Queue/api/filterInputIO"
+ */
+export declare function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>): 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 fluent fncts.io.Queue filterInput
+ * @tsplus location "@fncts/io/Queue/api/filterInputIO"
+ */
+export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean): PQueue<RA, RB, EA, EB, A1, B>;

package/Queue/api/filterOutputIO.d.ts

@@ -0,0 +1,31 @@
+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";
+import { QueueInternal } from "@fncts/io/Queue/definition";
+export declare class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB & RB1, EA, EB | EB1, A, B> {
+    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
+    readonly f: (b: B) => IO<RB1, EB1, boolean>;
+    constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    offer(a: A): IO<RA, EA, boolean>;
+    offerAll(as: Iterable<A>): IO<RA, EA, boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    take: IO<RB & RB1, EB1 | EB, B>;
+    takeAll: IO<RB & RB1, EB | EB1, Conc<B>>;
+    loop(max: number, acc: Conc<B>): IO<RB & RB1, EB | EB1, Conc<B>>;
+    takeUpTo(n: number): IO<RB & RB1, EB | EB1, Conc<B>>;
+}
+/**
+ * @tsplus fluent fncts.io.Queue filterOutputIO
+ * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
+ */
+export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>): PQueue<RA, RB & RB1, EA, EB | EB1, A, B>;
+/**
+ * @tsplus fluent fncts.io.Queue filterOutput
+ * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
+ */
+export declare function filterOutput_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, p: Predicate<B>): PQueue<RA, RB, EA, EB, A, B>;

package/Queue/api/operations.d.ts

@@ -0,0 +1,82 @@
+import { PQueue } from "@fncts/io/Queue/definition";
+import { UIO, IO } from "@fncts/io/IO/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: PQueue<RA, RB, EA, EB, A, B>): 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: PQueue<RA, RB, EA, EB, A, B>): 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: PQueue<RA, RB, EA, EB, A, B>): UIO<boolean>;
+/**
+ * Places one value in the queue.
+ * @tsplus fluent fncts.io.Queue offer
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A): 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 fluent fncts.io.Queue offerAll
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>): 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: PQueue<RA, RB, EA, EB, A, B>): 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: PQueue<RA, RB, EA, EB, A, B>): 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: PQueue<RA, RB, EA, EB, A, B>): import("../../IO").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: PQueue<RA, RB, EA, EB, A, B>): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
+/**
+ * Takes up to max number of values in the queue.
+ * @tsplus fluent fncts.io.Queue takeAllUpTo
+ * @tsplus location "@fncts/io/Queue/api/operations"
+ */
+export declare function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/poll.d.ts

@@ -0,0 +1,9 @@
+import { PQueue } from "@fncts/io/Queue/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * 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: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -0,0 +1,11 @@
+import { PQueue } from "@fncts/io/Queue/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * 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 fluent fncts.io.Queue takeBetween
+ * @tsplus location "@fncts/io/Queue/api/takeBetween"
+ */
+export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number): IO<RB, EB, Conc<B>>;