@fncts/base 0.0.31 → 0.0.33

package/control/Pure/runtime.d.ts

@@ -9,14 +9,14 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus pipeable fncts.control.Pure unsafeRunAll
  * @tsplus location "@fncts/base/control/Pure/runtime"
  */
-export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: import("./definition.js").Pure<W, S1, S2, never, E, A>) => readonly [import("../../collection/immutable/Conc.js").Conc<W>, import("../../data/Exit.js").Exit<E, readonly [S2, A]>];
+export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: Pure<W, S1, S2, never, E, A>) => readonly [Conc<W>, Exit<E, readonly [S2, A]>];
 /**
  * Runs this computation with the specified initial state, returning both
  * the updated state and the result.
  * @tsplus pipeable fncts.control.Pure unsafeRun
  * @tsplus location "@fncts/base/control/Pure/runtime"
  */
-export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => readonly [S2, A];
+export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>) => readonly [S2, A];
 /**
  * Runs this computation, returning the result.
  * @tsplus getter fncts.control.Pure unsafeRunResult
@@ -28,21 +28,21 @@ export declare function unsafeRunResult<W, A>(ma: Pure<W, unknown, unknown, neve
  * @tsplus pipeable fncts.control.Pure unsafeRunReader
  * @tsplus location "@fncts/base/control/Pure/runtime"
  */
-export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: import("./definition.js").Pure<W, unknown, never, R, never, A>) => A;
+export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: Pure<W, unknown, never, R, never, A>) => A;
 /**
  * Runs this computation with the specified initial state, returning the
  * updated state and discarding the result.
  * @tsplus pipeable fncts.control.Pure unsafeRunState
  * @tsplus location "@fncts/base/control/Pure/runtime"
  */
-export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => S2;
+export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>) => S2;
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  * @tsplus pipeable fncts.control.Pure unsafeRunStateResult
  * @tsplus location "@fncts/base/control/Pure/runtime"
  */
-export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => A;
+export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>) => A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Pure unsafeRunExit

package/control/Pure.d.ts

@@ -1,4 +1,4 @@
-export * from "./Pure/api.js";
-export * from "./Pure/definition.js";
-export * from "./Pure/instances.js";
 export * from "./Pure/runtime.js";
+export * from "./Pure/instances.js";
+export * from "./Pure/definition.js";
+export * from "./Pure/api.js";

package/control.d.ts

@@ -1,4 +1,5 @@
-export type {} from "./control/CompletablePromise.js";
-export type {} from "./control/Eval.js";
-export type {} from "./control/LazyValue.js";
 export type {} from "./control/Pure.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/InterruptiblePromise.js";
+export type {} from "./control/Eval.js";
+export type {} from "./control/CompletablePromise.js";

package/data/Cause/api.d.ts

@@ -101,7 +101,7 @@ export declare function failureMaybe<E>(self: Cause<E>): Maybe<E>;
  * @tsplus pipeable fncts.Cause filterDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function filterDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
+export declare function filterDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => Maybe<Cause<E>>;
 /**
  * Finds the first result matching `f`
  * @tsplus pipeable fncts.Cause find
@@ -274,7 +274,7 @@ export declare function stripFailures<A>(self: Cause<A>): Cause<never>;
  * @tsplus pipeable fncts.Cause stripSomeDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function stripSomeDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
+export declare function stripSomeDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => Maybe<Cause<E>>;
 /**
  * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
  * @tsplus getter fncts.Cause sequenceCauseEither
@@ -299,6 +299,7 @@ export declare function squashWith<E>(f: (e: E) => unknown): (self: Cause<E>) =>
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
  * @tsplus static fncts.CauseOps sequential
  * @tsplus static fncts.Cause.SequentialOps __call
+ * @tsplus operator fncts.Cause +
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;

package/data/Cause.d.ts

@@ -1,7 +1,7 @@
-export * from "./Cause/api.js";
 export * from "./Cause/definition.js";
-export * from "./Cause/api/fold.js";
-export * from "./Cause/api/isEmpty.js";
-export * from "./Cause/api/linearize.js";
-export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api.js";
 export * from "./Cause/api/unified.js";
+export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api/linearize.js";
+export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/api/fold.js";

package/data/Const.d.ts

@@ -1,3 +1,3 @@
-export * from "./Const/api.js";
-export * from "./Const/definition.js";
 export * from "./Const/instances.js";
+export * from "./Const/definition.js";
+export * from "./Const/api.js";

package/data/Datum/api.d.ts

@@ -124,7 +124,7 @@ export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Datu
  * @tsplus pipeable fncts.Datum getOrElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function getOrElse<B>(b: Lazy<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => B | A;
+export declare function getOrElse<B>(b: Lazy<B>): <A>(self: Datum<A>) => A | B;
 /**
  * @tsplus pipeable fncts.Datum match
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -149,7 +149,7 @@ export declare function map<A, B>(f: (a: A) => B): (self: Datum<A>) => Datum<B>;
  * @tsplus pipeable fncts.Datum orElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function orElse<B>(that: Lazy<Datum<B>>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<B | A>;
+export declare function orElse<B>(that: Lazy<Datum<B>>): <A>(self: Datum<A>) => Datum<A | B>;
 /**
  * @tsplus pipeable fncts.Datum partition
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -181,7 +181,7 @@ export declare const traverse: P.Traversable<DatumF>["traverse"];
  * @tsplus pipeable fncts.Datum zip
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function zip<B>(that: Datum<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<Zipped.Make<A, B>>;
+export declare function zip<B>(that: Datum<B>): <A>(self: Datum<A>) => Datum<Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.Datum zipWith
  * @tsplus location "@fncts/base/data/Datum/api"

package/data/DatumEither/api.d.ts

@@ -59,7 +59,7 @@ export declare function filter<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>)
  * @tsplus pipeable fncts.DatumEither filterMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
 /**
  * @tsplus pipeable fncts.DatumEither flatMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -69,22 +69,22 @@ export declare const flatMap: <A, E1, B>(f: (a: A) => DatumEither<E1, B>) => <E>
  * @tsplus pipeable fncts.DatumEither foldLeft
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: DatumEither<E, A>) => B;
 /**
  * @tsplus pipeable fncts.DatumEither foldMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: DatumEither<E, A>) => M;
 /**
  * @tsplus pipeable fncts.DatumEither foldRight
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: DatumEither<E, A>) => B;
 /**
  * @tsplus pipeable fncts.DatumEither getOrElse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B | C | A;
+export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: DatumEither<E, A>) => A | B | C;
 /**
  * @tsplus pipeable fncts.DatumEither map
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -142,7 +142,7 @@ export declare function partition<A>(p: Predicate<A>): <E>(self: DatumEither<E,
  * @tsplus pipeable fncts.DatumEither partitionMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => [import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>, import("@fncts/base/data/DatumEither/definition").DatumEither<E, C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <E>(self: DatumEither<E, A>) => [DatumEither<E, B>, DatumEither<E, C>];
 /**
  * @tsplus getter fncts.DatumEither toPending
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -168,4 +168,4 @@ export declare const zipWith: <A, E1, B, C>(that: DatumEither<E1, B>, f: (a: A,
  * @tsplus pipeable fncts.DatumEither zip
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function zip<E1, B>(that: DatumEither<E1, B>): <E, A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: DatumEither<E1, B>): <E, A>(self: DatumEither<E, A>) => DatumEither<E | E1, Zipped.Make<A, B>>;

package/data/DatumEither.d.ts

@@ -1,2 +1,2 @@
-export * from "./DatumEither/api.js";
 export * from "./DatumEither/definition.js";
+export * from "./DatumEither/api.js";

package/data/DecodeError.d.ts

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

package/data/Decoder/api.d.ts

@@ -13,7 +13,7 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
  * @tsplus pipeable fncts.Decoder __call
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare function decode(input: unknown): <A>(self: Decoder<A>) => import("../These").These<DecodeError, A>;
+export declare function decode(input: unknown): <A>(self: Decoder<A>) => These<DecodeError, A>;
 export declare function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A>;
 /**
  * @tsplus implicit

package/data/Decoder.d.ts

@@ -1,2 +1,2 @@
-export * from "./Decoder/api.js";
 export * from "./Decoder/definition.js";
+export * from "./Decoder/api.js";

package/data/Duration/api.d.ts

@@ -34,11 +34,6 @@ export declare function days(self: number): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function product(multiplicand: number): (self: Duration) => Duration;
-/**
- * @tsplus operator fncts.Duration *
- * @tsplus location "@fncts/base/data/Duration/api"
- */
-export declare function multiplyInverted(multiplicand: number, self: Duration): import("./definition").Duration;
 /**
  * @tsplus pipeable-operator fncts.Duration +
  * @tsplus location "@fncts/base/data/Duration/api"
@@ -65,3 +60,21 @@ export declare const zero: Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function lessThanOrEqualTo(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration greaterThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration >=
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function greaterThanOrEqualTo(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration lessThan
+ * @tsplus pipeable-operator fncts.Duration <
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function lessThan(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration greaterThan
+ * @tsplus pipeable-operator fncts.Duration >
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function greaterThan(that: Duration): (self: Duration) => boolean;

package/data/Duration.d.ts

@@ -1,2 +1,2 @@
-export * from "./Duration/api.js";
 export * from "./Duration/definition.js";
+export * from "./Duration/api.js";

package/data/Either/api/align.d.ts

@@ -4,4 +4,4 @@ import type { Either } from "../definition.js";
  * @tsplus pipeable fncts.Either align
  * @tsplus location "@fncts/base/data/Either/api/align"
  */
-export declare function align<E2, B>(fb: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E2 | E1, These<A, B>>;
+export declare function align<E2, B>(fb: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E1 | E2, These<A, B>>;

package/data/Either/api/alignWith.d.ts

@@ -4,4 +4,4 @@ import { These } from "../../These.js";
  * @tsplus pipeable fncts.Either alignWith
  * @tsplus location "@fncts/base/data/Either/api/alignWith"
  */
-export declare function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C): <E1>(self: Either<E1, A>) => Either<E2 | E1, C>;
+export declare function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;

package/data/Either/api.d.ts

@@ -11,7 +11,7 @@ import { Left, Right } from "./definition.js";
  * @tsplus pipeable fncts.Either ap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => import("./definition.js").Either<E2 | E1, B>;
+export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either bimap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -21,37 +21,37 @@ export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (
  * @tsplus pipeable fncts.Either catchAll
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchAll<E1, E2, B>(f: (e: E1) => Either<E2, B>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, B | A>;
+export declare function catchAll<E1, E2, B>(f: (e: E1) => Either<E2, B>): <A>(self: Either<E1, A>) => Either<E2, A | B>;
 /**
  * @tsplus pipeable fncts.Either catchJust
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchJust<E1, E2, B>(f: (e: E1) => Maybe<Either<E2, B>>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E1 | E2, B | A>;
+export declare function catchJust<E1, E2, B>(f: (e: E1) => Maybe<Either<E2, B>>): <A>(self: Either<E1, A>) => Either<E1 | E2, A | B>;
 /**
  * @tsplus pipeable fncts.Either catchMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchMap<E, B>(f: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<never, B | A>;
+export declare function catchMap<E, B>(f: (e: E) => B): <A>(self: Either<E, A>) => Either<never, A | B>;
 /**
  * @tsplus pipeable fncts.Either flatMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B>;
+export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: Either<E1, A>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either foldLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: import("./definition.js").Either<E, A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: Either<E, A>) => B;
 /**
  * @tsplus pipeable fncts.Either foldRight
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: import("./definition.js").Either<E, A>) => B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: Either<E, A>) => B;
 /**
  * @tsplus pipeable fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: import("./definition.js").Either<E, A>) => M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: Either<E, A>) => M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -66,7 +66,7 @@ export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
  * @tsplus pipeable fncts.Either getOrElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => B | A;
+export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: Either<E, A>) => A | B;
 /**
  * @tsplus static fncts.EitherOps isEither
  * @tsplus location "@fncts/base/data/Either/api"
@@ -89,12 +89,12 @@ export declare function isRight<E, A>(self: Either<E, A>): self is Right<A>;
  * @tsplus pipeable fncts.Either map
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <E>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: Either<E, A>) => Either<E, B>;
 /**
  * @tsplus pipeable fncts.Either mapLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function mapLeft<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, A>;
+export declare function mapLeft<E1, E2>(f: (e: E1) => E2): <A>(self: Either<E1, A>) => Either<E2, A>;
 /**
  * @tsplus getter fncts.Either value
  * @tsplus location "@fncts/base/data/Either/api"
@@ -104,7 +104,7 @@ export declare function merge<E, A>(self: Either<E, A>): E | A;
  * @tsplus pipeable fncts.Either orElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function orElse<E2, B>(that: Lazy<Either<E2, B>>): <E1, A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B | A>;
+export declare function orElse<E2, B>(that: Lazy<Either<E2, B>>): <E1, A>(self: Either<E1, A>) => Either<E1 | E2, A | B>;
 /**
  * @tsplus getter fncts.Either swap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -120,12 +120,12 @@ export declare const traverse_: P.Traversable<EitherF>["traverse"];
  * @tsplus pipeable fncts.Either zipWith
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, C>;
+export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;
 /**
  * @tsplus pipeable fncts.Either zip
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: Either<E, A>) => Either<E | E1, Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.Either filterMap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -151,5 +151,5 @@ export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M:
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
-export * from "./api/align.js";
 export * from "./api/alignWith.js";
+export * from "./api/align.js";

package/data/Either/constructors.d.ts

@@ -21,7 +21,7 @@ export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string
  * @tsplus pipeable fncts.Maybe toEither
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function fromMaybe<E>(nothing: Lazy<E>): <A>(self: import("../Maybe.js").Maybe<A>) => Either<E, A>;
+export declare function fromMaybe<E>(nothing: Lazy<E>): <A>(self: Maybe<A>) => Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromNullable
  * @tsplus location "@fncts/base/data/Either/constructors"

package/data/Either/destructors.d.ts

@@ -3,4 +3,7 @@ import { Either } from "@fncts/base/data/Either/definition";
  * @tsplus pipeable fncts.Either match
  * @tsplus location "@fncts/base/data/Either/destructors"
  */
-export declare function match<E, A, B, C>(left: (e: E) => B, right: (a: A) => C): (self: Either<E, A>) => B | C;
+export declare function match<E, A, B, C>(cases: {
+    Left: (e: E) => B;
+    Right: (a: A) => C;
+}): (self: Either<E, A>) => B | C;

package/data/Either.d.ts

@@ -1,5 +1,5 @@
-export * from "./Either/api.js";
-export * from "./Either/constructors.js";
-export * from "./Either/definition.js";
-export * from "./Either/destructors.js";
 export * from "./Either/instances.js";
+export * from "./Either/destructors.js";
+export * from "./Either/definition.js";
+export * from "./Either/constructors.js";
+export * from "./Either/api.js";

package/data/EitherT/api.d.ts

@@ -47,7 +47,7 @@ export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>)
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"

package/data/Encoder.d.ts

@@ -1,2 +1,2 @@
-export * from "./Encoder/api.js";
 export * from "./Encoder/definition.js";
+export * from "./Encoder/api.js";

package/data/Environment/ServiceNotFoundError.d.ts

@@ -0,0 +1,5 @@
+import { Tag } from "@fncts/base/data/Tag/definition";
+export declare class ServiceNotFoundError extends Error {
+    readonly tag: Tag<any, any>;
+    constructor(tag: Tag<any, any>);
+}

package/data/Environment/api.d.ts

@@ -1,28 +1,28 @@
 import { Tag } from "@fncts/base/data/Tag/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus pipeable fncts.Environment add
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<S | R>;
+export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
+export declare function add<H extends S, S = H, I = S>(service: H, tag: Tag<S, I>): <R>(self: Environment<R>) => Environment<R | I>;
 /**
  * @tsplus static fncts.EnvironmentOps empty
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare const empty: import("./definition").Environment<never>;
-type Tags<R> = R extends infer S ? Tag<S> : never;
+type Tags<R> = R extends infer S ? Tag<any, S> : never;
 /**
  * @tsplus pipeable fncts.Environment get
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function get<R, T extends Tags<R>>(tag: T): (self: Environment<R>) => T extends import("../Tag").Tag<infer S> ? S : never;
+export declare function get<R, T extends Tags<R>>(tag: T): (self: Environment<R>) => Tag.Service<T>;
 /**
  * @tsplus pipeable fncts.Environment getMaybe
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function getMaybe<S>(tag: Tag<S>): <R extends import("../../typeclass").Has<S>>(self: import("./definition").Environment<R>) => Maybe<S>;
+export declare function getMaybe<S, I>(tag: Tag<S, I>): <R>(self: Environment<R>) => Maybe<S>;
 /**
  * @tsplus static fncts.EnvironmentOps __call
  * @tsplus location "@fncts/base/data/Environment/api"
@@ -33,12 +33,12 @@ export declare function make(): Environment<never>;
  * @tsplus pipeable fncts.Environment union
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function union<R1>(that: Environment<R1>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<R & R1>;
+export declare function union<R1>(that: Environment<R1>): <R>(self: Environment<R>) => Environment<R & R1>;
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function unsafeGet<S>(tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => S;
+export declare function unsafeGet<S, I>(tag: Tag<S, I>): <R>(self: Environment<R>) => S;
 /**
  * @tsplus pipeable fncts.Environment update
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Environment.d.ts

@@ -1,2 +1,3 @@
-export * from "./Environment/api.js";
 export * from "./Environment/definition.js";
+export * from "./Environment/api.js";
+export * from "./Environment/ServiceNotFoundError.js";

package/data/EnvironmentPatch.d.ts

@@ -59,7 +59,7 @@ export declare function concrete(_: EnvironmentPatch<any, any>): asserts _ is Co
  * @tsplus pipeable fncts.Environment.Patch __call
  * @tsplus location "@fncts/base/data/EnvironmentPatch"
  */
-export declare function apply<In>(environment: Environment<In>): <Out>(patch: EnvironmentPatch<In, Out>) => import("./Environment").Environment<Out>;
+export declare function apply<In>(environment: Environment<In>): <Out>(patch: EnvironmentPatch<In, Out>) => Environment<Out>;
 /**
  * @tsplus pipeable fncts.Environment.Patch combine
  * @tsplus location "@fncts/base/data/EnvironmentPatch"

package/data/Equatable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Equatable/api.js";
-export * from "./Equatable/definition.js";
 export * from "./Equatable/fast-equals.js";
+export * from "./Equatable/definition.js";
+export * from "./Equatable/api.js";

package/data/Exit/api.d.ts

@@ -6,32 +6,32 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => import("./definition.js").Exit<E | G, B>;
+export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
  * @tsplus pipeable fncts.Exit zipRight
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit zipLeftConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
  * @tsplus pipeable fncts.Exit zipRightConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: Exit<E, A>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit bimap
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -56,17 +56,17 @@ export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G,
  * @tsplus pipeable fncts.Exit map
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <E>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(fa: Exit<E, A>) => Exit<E, B>;
 /**
  * @tsplus pipeable fncts.Exit mapError
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapError<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
+export declare function mapError<E1, E2>(f: (e: E1) => E2): <A>(self: Exit<E1, A>) => Exit<E2, A>;
 /**
  * @tsplus pipeable fncts.Exit mapErrorCause
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
+export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <A>(self: Exit<E1, A>) => Exit<E2, A>;
 /**
  * @tsplus pipeable fncts.Exit match
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -76,22 +76,22 @@ export declare function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSucce
  * @tsplus pipeable fncts.Exit zipWith
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
+export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
 /**
  * @tsplus pipeable fncts.Exit zip
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
+export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
+export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
 /**
  * @tsplus pipeable fncts.Exit zipConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
+export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithCause
  * @tsplus location "@fncts/base/data/Exit/api"

package/data/Exit.d.ts

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