@fncts/base 0.0.2 → 0.0.5

package/control/Eval/instance.d.ts

@@ -1,17 +1,20 @@
 import type { EvalF } from "@fncts/base/control/Eval/definition";
-import * as P from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 /**
  * @tsplus static fncts.control.EvalOps Functor
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Functor: P.Functor<EvalF>;
 /**
  * @tsplus static fncts.control.EvalOps Apply
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Apply: P.Apply<EvalF>;
 /**
  * @tsplus static fncts.control.EvalOps Applicative
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Applicative: P.Applicative<EvalF>;

package/control/Z/definition.d.ts

@@ -1,16 +1,8 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import type { _A, _E, _R, _S1, _S2, _W } from "../../types.js";
-export interface ZF extends HKT {
-    readonly type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
-    readonly variance: {
-        readonly W: "_";
-        readonly S: "_";
-        readonly R: "-";
-        readonly E: "+";
-        readonly A: "+";
-    };
+export interface ZF extends Z<any, any, any, any, any, any> {
+}
+export interface ZFixedF extends ZFixed<any, any, any, any, any> {
 }
 export declare const ZTypeId: unique symbol;
 export declare type ZTypeId = typeof ZTypeId;
@@ -29,17 +21,30 @@ export declare type ZTypeId = typeof ZTypeId;
  */
 export declare abstract class Z<W, S1, S2, R, E, A> {
     readonly _typeId: ZTypeId;
-    readonly _W: () => W;
-    readonly _S1: (_: S1) => void;
-    readonly _S2: () => S2;
-    readonly _R: (_: R) => void;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [HKT.F]: ZF;
+    readonly [HKT.W]: () => W;
+    readonly [HKT.Q]: (_: S1) => void;
+    readonly [HKT.S]: () => S2;
+    readonly [HKT.R]: (_: R) => void;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Z<HKT._W<this>, HKT._Q<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+}
+export interface ZFixed<W, S, R, E, A> {
+    readonly _typeId: ZTypeId;
+    readonly [HKT.F]: ZF;
+    readonly [HKT.W]: () => W;
+    readonly [HKT.Q]: (_: S) => void;
+    readonly [HKT.S]: () => S;
+    readonly [HKT.R]: (_: R) => void;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Z<HKT._W<this>, HKT._S<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
 }
 /**
  * @tsplus unify fncts.control.Z
  */
-export declare function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<_W<X>, _S1<X>, _S2<X>, _R<X>, _E<X>, _A<X>>;
+export declare function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<HKT._W<X>, HKT._Q<X>, HKT._S<X>, HKT._R<X>, HKT._E<X>, HKT._A<X>>;
 /**
  * @tsplus static fncts.control.ZOps isZ
  * @tsplus location "@fncts/base/control/Z/definition"

package/control/Z/instances.d.ts

@@ -1,7 +1,8 @@
-import type { ZF } from "./definition.js";
-import * as P from "../../typeclass.js";
+import type * as P from "../../typeclass.js";
+import type { ZFixedF } from "./definition.js";
 /**
  * @tsplus static fncts.control.ZOps Applicative
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Z/instances"
  */
-export declare const Applicative: P.Applicative<ZF>;
+export declare const Applicative: P.Applicative<ZFixedF>;

package/data/Branded/definition.d.ts

@@ -0,0 +1,36 @@
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { Union } from "@fncts/typelevel";
+declare type Brand_<A, K extends string> = Brand<A, K>;
+export declare namespace Branded {
+    const Symbol: unique symbol;
+    type Symbol = typeof Symbol;
+    interface Brand<A, K extends string> {
+        readonly [Branded.Symbol]: {
+            [_ in K]: A;
+        };
+    }
+    type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
+    type Validated<A, K extends string> = A & Brand<A, K>;
+    type IsValidated<P extends Brand<any, any>> = {
+        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1;
+    }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
+    type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
+    type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
+        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? K extends string ? Brand<P[Branded.Symbol][K], K> : never : never;
+    }[keyof P[Branded.Symbol]]>;
+}
+/**
+ * @tsplus type fncts.Brand
+ * @tsplus companion fncts.BrandOps
+ */
+export declare class Brand<A, K extends string> {
+    readonly validate: Refinement<A, A & Branded.Brand<A, K>>;
+    constructor(validate: Refinement<A, A & Branded.Brand<A, K>>);
+}
+/**
+ * @tsplus static fncts.BrandOps __call
+ * @tsplus location "@fncts/base/data/Branded/definition"
+ */
+export declare function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K>;
+export {};

package/data/Branded/derivations.d.ts

@@ -0,0 +1,24 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Check } from "@fncts/typelevel/Check";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ * @tsplus location "@fncts/base/data/Branded/derivations"
+ */
+export declare function deriveGuard<A extends Branded.Brand<any, any>>(...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True ? [
+    base: Guard<Branded.Unbrand<A>>,
+    brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+    }
+] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Branded/derivations"
+ */
+export declare function deriveDecoder<A extends Branded.Brand<any, any>>(...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True ? [
+    base: Decoder<Branded.Unbrand<A>>,
+    brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+    }
+] : never): Decoder<A>;

package/data/Branded.d.ts

@@ -0,0 +1,2 @@
+export * from "./Branded/definition.js";
+export * from "./Branded/derivations.js";

package/data/Cause/api.d.ts

@@ -6,7 +6,7 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { Both, Cause, Fail, Halt, Then } from "./definition.js";
+import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
 /**
  * @tsplus fluent fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
@@ -181,6 +181,12 @@ export declare function isHalt<E>(self: Cause<E>): self is Halt;
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function isThen<E>(self: Cause<E>): self is Then<E>;
+/**
+ * A type-guard matching `Interrupt`
+ * @tsplus fluent fncts.Cause isInterrupt
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isInterrupt<E>(self: Cause<E>): self is Interrupt;
 /**
  * A type-guard matching `Traced`
  * @tsplus getter fncts.Cause isTraced

package/data/Const/api.d.ts

@@ -1,4 +1,4 @@
-import type { Const } from "./definition.js";
+import { Const } from "./definition.js";
 /**
  * @tsplus fluent fncts.Const map
  * @tsplus location "@fncts/base/data/Const/api"

package/data/Const/definition.d.ts

@@ -1,12 +1,28 @@
 /**
- * @tsplus type fncts.Const
+ * @tsplus type fncts.ConstF
  */
-export declare type Const<E, A> = E & {
-    readonly _A: A;
-};
+export interface ConstF extends Const<any, any> {
+}
 /**
- * @tsplus type fncts.ConstOps
+ * @tsplus type fncts.ConstF
  */
-export interface ConstOps {
+export interface Const1F<E> extends Const1<E, any> {
+}
+/**
+ * @tsplus type fncts.Const
+ * @tsplus companion fncts.ConstOps
+ */
+export declare class Const<E, A> {
+    readonly getConst: E;
+    readonly [HKT.F]: ConstF;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Const<HKT._E<this>, HKT._A<this>>;
+    constructor(getConst: E);
+}
+export interface Const1<E, A> {
+    readonly [HKT.F]: ConstF;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Const<E, HKT._A<this>>;
 }
-export declare const Const: ConstOps;

package/data/Const/instances.d.ts

@@ -1,20 +1,12 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Const } from "@fncts/base/data/Const/definition";
-import * as P from "../../typeclass.js";
-export interface ConstF extends HKT {
-    readonly type: Const<this["E"], this["A"]>;
-    readonly variance: {
-        E: "_";
-        A: "_";
-    };
-}
+import type * as P from "../../typeclass.js";
+import type { Const1F } from "@fncts/base/data/Const/definition";
 /**
  * @tsplus static fncts.ConstOps getApply
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<ConstF, HKT.Fix<"E", E>>;
+export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<Const1F<E>>;
 /**
  * @tsplus static fncts.ConstOps getApplicative
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>>;
+export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<Const1F<E>>;

package/data/DecodeError/definition.d.ts

@@ -0,0 +1,141 @@
+import { Eval } from "@fncts/base/control/Eval/definition";
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+export declare const DecodeErrorTypeId: unique symbol;
+export declare type DecodeErrorTypeId = typeof DecodeErrorTypeId;
+export declare abstract class DecodeError {
+    readonly _typeId: DecodeErrorTypeId;
+    abstract render: Eval<RoseTree<string>>;
+}
+export declare class RequiredKeyError extends DecodeError {
+    readonly key: string;
+    readonly error: DecodeError;
+    readonly _tag = "RequiredKey";
+    constructor(key: string, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class OptionalKeyError extends DecodeError {
+    readonly key: PropertyKey;
+    readonly error: DecodeError;
+    readonly _tag = "OptionalKey";
+    constructor(key: PropertyKey, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class RequiredIndexError<I, E extends DecodeError> extends DecodeError {
+    readonly index: I;
+    readonly error: E;
+    readonly _tag = "RequiredIndex";
+    constructor(index: I, error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class OptionalIndexError<I, E extends DecodeError> extends DecodeError {
+    readonly index: I;
+    readonly error: E;
+    readonly _tag = "RequiredIndex";
+    constructor(index: I, error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class LazyError<E extends DecodeError> extends DecodeError {
+    readonly error: E;
+    readonly _tag = "Lazy";
+    constructor(error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MemberError extends DecodeError {
+    readonly label: string;
+    readonly error: DecodeError;
+    readonly _tag = "Member";
+    constructor(label: string, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class CompoundError<E extends DecodeError> extends DecodeError {
+    readonly name: string;
+    readonly errors: Vector<E>;
+    readonly _tag = "Compound";
+    constructor(name: string, errors: Vector<E>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class CompositionError<E extends DecodeError> extends DecodeError {
+    readonly errors: Vector<E>;
+    readonly _tag = "Composition";
+    constructor(errors: Vector<E>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class StringError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "String";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class NumberError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "Number";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class NaNError extends DecodeError {
+    readonly _tag = "NaN";
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class InfinityError extends DecodeError {
+    readonly _tag = "Infinity";
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class BooleanError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "Boolean";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class PrimitiveError extends DecodeError {
+    readonly actual: unknown;
+    readonly name: string;
+    readonly _tag = "Primitive";
+    constructor(actual: unknown, name: string);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class LiteralError<A extends string | number | boolean> extends DecodeError {
+    readonly actual: unknown;
+    readonly literals: Vector<A>;
+    readonly _tag = "Literal";
+    constructor(actual: unknown, literals: Vector<A>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnexpectedKeysError extends DecodeError {
+    readonly keys: Vector<string>;
+    readonly _tag = "UnexpectedKeys";
+    constructor(keys: Vector<string>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnexpectedIndicesError extends DecodeError {
+    readonly indices: Vector<number>;
+    readonly _tag = "UnexpectedIndices";
+    constructor(indices: Vector<number>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MissingKeyError extends DecodeError {
+    readonly key: PropertyKey;
+    readonly _tag = "MissingKeys";
+    constructor(key: PropertyKey);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MissingIndicesError extends DecodeError {
+    readonly keys: Vector<PropertyKey>;
+    readonly _tag = "MissingIndices";
+    constructor(keys: Vector<PropertyKey>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class BrandedError extends DecodeError {
+    readonly name: string;
+    readonly brands: Vector<string>;
+    readonly _tag = "BrandedError";
+    constructor(name: string, brands: Vector<string>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnionError extends DecodeError {
+    readonly label: string;
+    readonly errors: Vector<DecodeError>;
+    readonly _tag = "UnionError";
+    constructor(label: string, errors: Vector<DecodeError>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}

package/data/DecodeError.d.ts

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

package/data/Decoder/api.d.ts

@@ -0,0 +1,65 @@
+import { These } from "@fncts/base/data/These";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+/**
+ * @tsplus fluent fncts.Decoder __call
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function decode<I, E, A>(self: Decoder<A>, input: unknown): These<DecodeError, A>;
+export declare function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const string: Decoder<string>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const number: Decoder<number>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const boolean: Decoder<boolean>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const record: Decoder<{}>;
+/**
+ * @tsplus derive fncts.Decoder lazy
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveLazy<A>(f: (_: Decoder<A>) => Decoder<A>): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder<_> 20
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveLiteral<A extends string | number | boolean>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder<|> 30
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveUnion<A extends ReadonlyArray<unknown>>(...elements: {
+    [K in keyof A]: Decoder<A[K]>;
+}): Decoder<A[number]>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [k in RequiredKeys<A>]: Decoder<A[k]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [k in OptionalKeys<A>]: Decoder<NonNullable<A[k]>>;
+        }
+    ])
+] : never): Decoder<A>;

package/data/Decoder/definition.d.ts

@@ -0,0 +1,24 @@
+import { These } from "@fncts/base/data/These";
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+export declare const DecoderTypeId: unique symbol;
+export declare type DecoderTypeId = typeof DecoderTypeId;
+export interface DecoderF extends Decoder<any> {
+}
+/**
+ * @tsplus type fncts.Decoder
+ * @tsplus companion fncts.DecoderOps
+ */
+export declare class Decoder<A> {
+    readonly decode: (input: unknown) => These<DecodeError, A>;
+    readonly label: string;
+    readonly _typeId: DecoderTypeId;
+    readonly [HKT.F]: DecoderF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Decoder<HKT._A<this>>;
+    constructor(decode: (input: unknown) => These<DecodeError, A>, label: string);
+}
+/**
+ * @tsplus static fncts.DecoderOps __call
+ * @tsplus location "@fncts/base/data/Decoder/definition"
+ */
+export declare function makeDecoder<A>(decode: (input: unknown) => These<DecodeError, A>, label: string): Decoder<A>;

package/data/Decoder.d.ts

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

package/data/Duration/api.d.ts

@@ -1,45 +1,44 @@
 import { Duration } from "@fncts/base/data/Duration/definition";
-import type { IsInt } from "@fncts/base/types";
 /**
  * @tsplus getter fncts.Number milliseconds
  * @tsplus static fncts.DurationOps milliseconds
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function milliseconds<N extends number>(self: IsInt<N>): Duration;
+export declare function milliseconds(self: number): Duration;
 /**
  * @tsplus getter fncts.Number seconds
  * @tsplus static fncts.DurationOps seconds
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function seconds<N extends number>(self: IsInt<N>): Duration;
+export declare function seconds(self: number): Duration;
 /**
  * @tsplus getter fncts.Number minutes
  * @tsplus static fncts.DurationOps minutes
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function minutes<N extends number>(self: IsInt<N>): Duration;
+export declare function minutes(self: number): Duration;
 /**
  * @tsplus getter fncts.Number hours
  * @tsplus static fncts.DurationOps hours
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function hours<N extends number>(self: IsInt<N>): Duration;
+export declare function hours(self: number): Duration;
 /**
  * @tsplus getter fncts.Number days
  * @tsplus static fncts.DurationOps days
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function days<N extends number>(self: IsInt<N>): Duration;
+export declare function days(self: number): Duration;
 /**
  * @tsplus operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function mult<N extends number>(self: Duration, multiplicand: IsInt<N>): import("./definition").Duration;
+export declare function mult(self: Duration, multiplicand: number): import("./definition").Duration;
 /**
  * @tsplus operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function multInverted<N extends number>(multiplicand: IsInt<N>, self: Duration): import("./definition").Duration;
+export declare function multInverted(multiplicand: number, self: Duration): import("./definition").Duration;
 /**
  * @tsplus operator fncts.Duration +
  * @tsplus location "@fncts/base/data/Duration/api"
@@ -50,3 +49,8 @@ export declare function sum(self: Duration, that: Duration): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function difference(self: Duration, that: Duration): Duration;
+/**
+ * @tsplus static fncts.DurationOps fromInterval
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function fromInterval(start: number, end: number): Duration;

package/data/Either/api.d.ts

@@ -1,8 +1,9 @@
 import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type * as P from "../../typeclass.js";
-import type { EitherF } from "./instances.js";
+import type { EitherF } from "./definition.js";
 import { Left, Right } from "./definition.js";
 /**
  * @tsplus fluent fncts.Either ap
@@ -45,14 +46,10 @@ export declare function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a
  */
 export declare function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: P.Monoid<M>): <E, A>(self: import("./definition.js").Either<E, A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Either foldMap
+ * @tsplus fluent fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMapSelf<E, A>(self: Either<E, A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<E, A, M>(self: Either<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -105,24 +102,39 @@ export declare function merge<E, A>(self: Either<E, A>): E | A;
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B>;
-export declare const sequence: P.sequence<EitherF>;
-/**
- * @tsplus getter fncts.Either sequence
- * @tsplus location "@fncts/base/data/Either/api"
- */
-export declare const sequenceSelf: P.sequenceSelf<EitherF>;
 /**
  * @tsplus getter fncts.Either swap
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
-export declare const traverse_: P.traverse_<EitherF>;
-export declare const traverse: P.traverse<EitherF>;
 /**
- * @tsplus getter fncts.Either traverse
+ * @tsplus fluent fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare const traverseSelf: P.traverseSelf<EitherF>;
+export declare const traverse_: P.Traversable<EitherF>["traverse"];
 export declare function zipWith_<E1, A, E2, B, C>(self: Either<E1, A>, fb: Either<E2, B>, f: (a: A, b: B) => C): Either<E1 | E2, C>;
+/**
+ * @tsplus fluent fncts.Either filterMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function filterMap<E, A, B>(self: Either<E, A>, f: (a: A) => Maybe<B>, 
+/** @tsplus auto */ M: P.Monoid<E>): Either<E, B>;
+/**
+ * @tsplus fluent fncts.Either filter
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function filter<E, A>(self: Either<E, A>, f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): Either<E, A>;
+/**
+ * @tsplus fluent fncts.Either partitionMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function partitionMap<E, A, B, C>(self: Either<E, A>, f: (a: A) => Either<B, C>, 
+/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, B>, Either<E, C>];
+/**
+ * @tsplus fluent fncts.Either partition
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function partition<E, A>(self: Either<E, A>, p: Predicate<A>, 
+/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, A>, Either<E, A>];
 export * from "./api/align.js";
 export * from "./api/alignWith.js";