@fncts/base 0.0.13 → 0.0.14

package/control/Z/api.d.ts

@@ -37,12 +37,12 @@ export declare function bimap_<W, S1, S2, R, E, A, G, B>(pab: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z catchAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R & R1, E1, A | B>;
+export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R | R1, E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z catchJust
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R & R1, E | E1, A | B>;
+export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R | R1, E | E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z flatMap
  * @tsplus location "@fncts/base/control/Z/api"
@@ -108,22 +108,22 @@ export declare function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<
  * @tsplus static fncts.control.ZOps fail
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCause
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus getter fncts.control.Z flatten
  * @tsplus location "@fncts/base/control/Z/api"
@@ -134,12 +134,12 @@ export declare function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(mma: Z<W, S1
  * @tsplus static fncts.control.ZOps get
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function get<S>(): Z<never, S, S, unknown, never, S>;
+export declare function get<S>(): Z<never, S, S, never, never, S>;
 /**
  * @tsplus static fncts.control.ZOps gets
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A>;
+export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps getsZ
  * @tsplus location "@fncts/base/control/Z/api"
@@ -149,12 +149,12 @@ export declare function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>):
  * @tsplus static fncts.control.ZOps halt
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus static fncts.control.ZOps haltNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus getter fncts.control.Z listen
  * @tsplus location "@fncts/base/control/Z/api"
@@ -201,17 +201,17 @@ export declare function match_<W, S1, S2, R, E, A, B, C>(fa: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z matchZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchCauseZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchLogZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * Recovers from errors by accepting one computation to execute for the case
  * of an error, and one computation to execute for the case of success. More powerful
@@ -227,25 +227,25 @@ export declare function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1,
  * @tsplus static fncts.control.ZOps modify
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A>;
+export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A>;
 /**
  * Constructs a computation that may fail from the specified modify function.
  * @tsplus static fncts.control.ZOps modifyEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A>;
+export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A>;
 /**
  * @tsplus fluent fncts.control.Z orElse
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1>;
+export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1>;
 /**
  * Executes this computation and returns its value, if it succeeds, but
  * otherwise executes the specified computation.
  * @tsplus fluent fncts.control.Z orElseEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>>;
+export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>>;
 /**
  * @tsplus fluent fncts.control.Z provideEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
@@ -256,7 +256,7 @@ export declare function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2,
  * @tsplus static fncts.control.ZOps put
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function put<S>(s: S): Z<never, unknown, S, unknown, never, void>;
+export declare function put<S>(s: S): Z<never, unknown, S, never, never, void>;
 /**
  * Repeats this computation the specified number of times (or until the first failure)
  * passing the updated state to each successive repetition.
@@ -275,12 +275,12 @@ export declare function repeatUntil_<W, S1, S2 extends S1, R, E, A>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps succeed
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps succeedNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus fluent fncts.control.Z tap
  * @tsplus location "@fncts/base/control/Z/api"
@@ -290,12 +290,12 @@ export declare function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps tell
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tell<W>(w: W): Z<W, unknown, never, unknown, never, void>;
+export declare function tell<W>(w: W): Z<W, unknown, never, never, never, void>;
 /**
  * @tsplus static fncts.control.ZOps tellAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void>;
+export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void>;
 /**
  * Like `map`, but also allows the state to be modified.
  * @tsplus fluent fncts.control.Z transform
@@ -306,13 +306,13 @@ export declare function transform_<W, S1, S2, R, E, A, S3, B>(ma: Z<W, S1, S2, R
  * @tsplus static fncts.control.ZOps unit
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare const unit: Z<never, unknown, never, unknown, never, void>;
+export declare const unit: Z<never, unknown, never, never, never, void>;
 /**
  * Constructs a computation from the specified update function.
  * @tsplus static fncts.control.ZOps update
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void>;
+export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void>;
 /**
  * @tsplus fluent fncts.control.Z write
  * @tsplus location "@fncts/base/control/Z/api"

package/control/Z/definition.d.ts

@@ -32,7 +32,7 @@ export declare abstract class Z<W, S1, S2, R, E, A> {
     readonly _W: () => W;
     readonly _S1: (_: S1) => void;
     readonly _S2: () => S2;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => A;
 }
@@ -71,12 +71,12 @@ export declare const enum ZTag {
     Listen = "Listen",
     MapLog = "MapLog"
 }
-export declare class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
     readonly value: A;
     readonly _tag = ZTag.SucceedNow;
     constructor(value: A);
 }
-export declare class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class Succeed<A> extends Z<never, unknown, never, never, never, A> {
     readonly effect: () => A;
     readonly _tag = ZTag.Succeed;
     constructor(effect: () => A);
@@ -86,12 +86,12 @@ export declare class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
     readonly _tag = ZTag.Defer;
     constructor(make: () => Z<W, S1, S2, R, E, A>);
 }
-export declare class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export declare class Fail<E> extends Z<never, unknown, never, never, E, never> {
     readonly cause: Cause<E>;
     readonly _tag = ZTag.Fail;
     constructor(cause: Cause<E>);
 }
-export declare class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export declare class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
     readonly run: (s1: S1) => readonly [A, S2];
     readonly _tag = ZTag.Modify;
     constructor(run: (s1: S1) => readonly [A, S2]);
@@ -120,7 +120,7 @@ export declare class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E,
     readonly _tag = ZTag.Provide;
     constructor(ma: Z<W, S1, S2, R, E, A>, env: Environment<R>);
 }
-export declare class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
+export declare class Tell<W> extends Z<W, unknown, never, never, never, void> {
     readonly log: Conc<W>;
     readonly _tag = ZTag.Tell;
     constructor(log: Conc<W>);

package/control/Z/runtime.d.ts

@@ -35,22 +35,22 @@ export declare function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, ne
  * @tsplus fluent fncts.control.Z unsafeRunState
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2;
+export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2;
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A;
+export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Z unsafeRunExit
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A>;
+export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A>;
 /**
  * @tsplus getter fncts.control.Z unsafeRunWriter
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A];
+export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A];

package/control.d.ts

@@ -0,0 +1,3 @@
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";

package/data/DecodeError/definition.d.ts

@@ -139,3 +139,9 @@ export declare class UnionError extends DecodeError {
     constructor(label: string, errors: Vector<DecodeError>);
     render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
 }
+export declare class EmptyError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "EmptyError";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}

package/data/DecodeError/instances.d.ts

@@ -0,0 +1 @@
+export {};

package/data/DecodeError.d.ts

@@ -1 +1,2 @@
 export * from "./DecodeError/definition.js";
+export * from "./DecodeError/instances.js";

package/data/Maybe/definition.d.ts

@@ -18,7 +18,7 @@ export interface MaybeF extends HKT {
  * @tsplus companion fncts.MaybeOps
  */
 export declare class Maybe<A> {
-    readonly _A: () => A;
+    _A: () => A;
     readonly _typeId: MaybeTypdId;
 }
 /**
@@ -44,7 +44,9 @@ export declare class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never>;
+export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{
+    _A: () => infer A;
+}] ? A : never>;
 /**
  * @tsplus static fncts.MaybeOps isMaybe
  * @tsplus location "@fncts/base/data/Maybe/definition"

package/data/string/api.d.ts

@@ -139,7 +139,7 @@ export declare function under_(s: string, f: (chars: Array<string>) => Array<str
 export declare const under: (f: (chars: Array<string>) => Array<string>) => (s: string) => string;
 /**
  * Join newline-separated strings together.
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  * @tsplus location "@fncts/base/data/string/api"
  */
 export declare function unlines(as: ReadonlyArray<string>): string;

package/data.d.ts

@@ -0,0 +1,33 @@
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";

package/global.d.ts

@@ -0,0 +1,237 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/collection/compat/Array";
+/**
+ * @tsplus global
+ */
+import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus global
+ */
+import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+/**
+ * @tsplus global
+ */
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus global
+ */
+import { ImmutableNonEmptyArray, NonEmptyArray, ReadonlyNonEmptyArray, } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+/**
+ * @tsplus global
+ */
+import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
+/**
+ * @tsplus global
+ */
+import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+/**
+ * @tsplus global
+ */
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+/**
+ * @tsplus global
+ */
+import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
+/**
+ * @tsplus global
+ */
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+/**
+ * @tsplus global
+ */
+import { Iterable } from "@fncts/base/collection/Iterable/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap as MutableHashMap } from "@fncts/base/collection/mutable/HashMap";
+/**
+ * @tsplus global
+ */
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
+/**
+ * @tsplus global
+ */
+import { Eval } from "@fncts/base/control/Eval/definition";
+/**
+ * @tsplus global
+ */
+import { LazyValue } from "@fncts/base/control/LazyValue";
+/**
+ * @tsplus global
+ */
+import { Z } from "@fncts/base/control/Z/definition";
+/**
+ * @tsplus global
+ */
+import { Byte } from "@fncts/base/data/Byte";
+/**
+ * @tsplus global
+ */
+import { CaseClass } from "@fncts/base/data/CaseClass";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus global
+ */
+import { Const } from "@fncts/base/data/Const/definition";
+/**
+ * @tsplus global
+ */
+import { Datum } from "@fncts/base/data/Datum/definition";
+/**
+ * @tsplus global
+ */
+import { DatumEither } from "@fncts/base/data/DatumEither/definition";
+/**
+ * @tsplus global
+ */
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus global
+ */
+import { Duration } from "@fncts/base/data/Duration/definition";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import { ArrayIndexOutOfBoundsError, IllegalArgumentError, IllegalStateError, IndexOutOfBoundsError, InterruptedException, InvalidCapacityError, isInterruptedException, isInvalidCapacityError, NoSuchElementError, } from "@fncts/base/data/exceptions";
+/**
+ * @tsplus global
+ */
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit/definition";
+/**
+ * @tsplus global
+ */
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+/**
+ * @tsplus global
+ */
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function/definition";
+/**
+ * @tsplus global
+ */
+import { Identity } from "@fncts/base/data/Identity/definition";
+/**
+ * @tsplus global
+ */
+import { Interval } from "@fncts/base/data/Interval";
+/**
+ * @tsplus global
+ */
+import { Intervals } from "@fncts/base/data/Intervals";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, MaybeTag, Nothing } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus global
+ */
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/number/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/string/definition";
+/**
+ * @tsplus global
+ */
+import { Struct } from "@fncts/base/data/Struct/definition";
+/**
+ * @tsplus global
+ */
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus global
+ */
+import { These } from "@fncts/base/data/These";
+/**
+ * @tsplus global
+ */
+import { Trace } from "@fncts/base/data/Trace/definition";
+/**
+ * @tsplus global
+ */
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+/**
+ * @tsplus global
+ */
+import { Zipped } from "@fncts/base/data/Zipped";
+/**
+ * @tsplus global
+ */
+import { Stack } from "@fncts/base/internal/Stack";
+/**
+ * @tsplus global
+ */
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+/**
+ * @tsplus global
+ */
+import { Guard } from "@fncts/base/typeclass/Guard";
+/**
+ * @tsplus global
+ */
+import { Has } from "@fncts/base/typeclass/Has";
+/**
+ * @tsplus global
+ */
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+/**
+ * @tsplus global
+ */
+import { hasTypeId, isByte, isObject } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { HKT } from "@fncts/typelevel/HKT";
+export {};

package/index.d.ts

@@ -0,0 +1,8 @@
+export type {} from "./collection.js";
+export type {} from "./control.js";
+export type {} from "./data.js";
+export type {} from "./json.js";
+export type {} from "./optics.js";
+export type {} from "./typeclass.js";
+export type {} from "./types.js";
+export type {} from "./util.js";

package/json.d.ts

@@ -0,0 +1,3 @@
+export type {} from "./json/EitherJson.js";
+export type {} from "./json/MaybeJson.js";
+export type {} from "./json/TheseJson.js";

package/optics.d.ts

@@ -0,0 +1,10 @@
+export type {} from "./optics/At.js";
+export type {} from "./optics/Fold.js";
+export type {} from "./optics/Getter.js";
+export type {} from "./optics/Index.js";
+export type {} from "./optics/Iso.js";
+export type {} from "./optics/Lens.js";
+export type {} from "./optics/Optional.js";
+export type {} from "./optics/Prism.js";
+export type {} from "./optics/Setter.js";
+export type {} from "./optics/Traversal.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "dependencies": {
     "@fncts/typelevel": "0.0.11"
   },

package/typeclass/Showable/show.d.ts

@@ -31,7 +31,7 @@ export interface ShowOptions {
 }
 export declare class ShowContext extends CaseClass<ShowContextArgs> {
 }
-export declare type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export declare type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export declare type ShowComputation = ShowComputationZ<string>;
 export declare type ShowComputationChunk = ShowComputationZ<Conc<string>>;
 export interface ShowComputationPrimitive {

package/util.d.ts

@@ -0,0 +1,6 @@
+export type {} from "./util/AnsiFormat.js";
+export type {} from "./util/assert.js";
+export type {} from "./util/pattern.js";
+export type {} from "./util/PCGRandom.js";
+export type {} from "./util/predicates.js";
+export type {} from "./util/rand.js";