@fncts/base 0.0.3 → 0.0.4

package/data/Identity/instances.d.ts

@@ -1,21 +1,17 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Identity } from "@fncts/base/data/Identity/definition";
-import * as P from "../../typeclass.js";
-export interface IdentityF extends HKT {
-    readonly type: Identity<this["A"]>;
-}
+import type * as P from "../../typeclass.js";
+import type { IdentityN } from "@fncts/base/data/Identity/definition";
 /**
  * @tsplus static fncts.IdentityOps Functor
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Functor: P.Functor<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Functor: P.Functor<IdentityN>;
 /**
  * @tsplus static fncts.IdentityOps Apply
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Apply: P.Apply<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Apply: P.Apply<IdentityN>;
 /**
  * @tsplus static fncts.IdentityOps Applicative
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Applicative: P.Applicative<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Applicative: P.Applicative<IdentityN>;

package/data/Interval.d.ts

@@ -0,0 +1,71 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus type fncts.io.Schedule.Interval
+ * @tsplus companion fncts.io.Schedule.IntervalOps
+ */
+export declare class Interval {
+    readonly startMilliseconds: number;
+    readonly endMilliseconds: number;
+    constructor(startMilliseconds: number, endMilliseconds: number);
+}
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps after
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function after(start: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps before
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function before(end: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps empty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare const empty: Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isEmpty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function isEmpty(self: Interval): boolean;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function intersect_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval lt
+ * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function lt_(self: Interval, that: Interval): boolean;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps __call
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function makeInterval(start: number, end: number): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function max_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function min_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function isNonEmpty(self: Interval): boolean;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval size
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function size(self: Interval): number;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function union_(self: Interval, that: Interval): Maybe<Interval>;

package/data/Maybe/api.d.ts

@@ -3,7 +3,6 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import type { MaybeF } from "./instances.js";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
 /**
@@ -11,11 +10,6 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B>;
-/**
- * @tsplus static fncts.MaybeOps sequenceS
- * @tsplus location "@fncts/base/data/Maybe/api"
- */
-export declare const sequenceS: import("@fncts/base/typeclass").sequenceS<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
@@ -23,15 +17,11 @@ export declare const sequenceS: import("@fncts/base/typeclass").sequenceS<MaybeF
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B>;
-/**
- * @constrained
- */
-export declare function elem_<A>(E: Eq<A>): (self: Maybe<A>, elem: A) => boolean;
 /**
  * @tsplus fluent fncts.Maybe elem
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function elemSelf<A>(self: Maybe<A>): (E: Eq<A>) => (elem: A) => boolean;
+export declare function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean;
 /**
  * @constrained
  * @tsplus fluent fncts.Maybe exists
@@ -76,14 +66,10 @@ export declare function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) =>
  */
 export declare function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: Monoid<M>): <A>(self: import("./definition.js").Maybe<A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Maybe foldMap
+ * @tsplus fluent fncts.Maybe foldMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldMapSelf<A>(self: Maybe<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<A, M>(self: Maybe<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  * @tsplus fluent fncts.Maybe getOrElse

package/data/Maybe/definition.d.ts

@@ -4,13 +4,23 @@ export declare const enum MaybeTag {
 }
 export declare const MaybeTypeId: unique symbol;
 export declare type MaybeTypdId = typeof MaybeTypeId;
+export declare type MaybeF = Maybe<any>;
+/**
+ * @tsplus type fncts.Maybe
+ * @tsplus companion fncts.MaybeOps
+ */
+export declare class Maybe<A> {
+    readonly _typeId: MaybeTypdId;
+    readonly [HKT.F]: MaybeF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Maybe<HKT._A<this>>;
+}
 /**
  * @tsplus type fncts.Just
  * @tsplus companion fncts.JustOps
  */
-export declare class Just<A> {
+export declare class Just<A> extends Maybe<A> {
     readonly value: A;
-    readonly _typeId: MaybeTypdId;
     readonly _tag = MaybeTag.Just;
     constructor(value: A);
     [Symbol.equals](that: unknown): boolean;
@@ -20,22 +30,11 @@ export declare class Just<A> {
  * @tsplus type fncts.Nothing
  * @tsplus companion fncts.NothingOps
  */
-export declare class Nothing {
-    readonly _typeId: MaybeTypdId;
+export declare class Nothing extends Maybe<never> {
     readonly _tag = MaybeTag.Nothing;
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
-/**
- * @tsplus type fncts.Maybe
- */
-export declare type Maybe<A> = Just<A> | Nothing;
-/**
- * @tsplus type fncts.MaybeOps
- */
-export interface MaybeOps {
-}
-export declare const Maybe: MaybeOps;
 /**
  * @tsplus unify fncts.Maybe
  */
@@ -57,3 +56,10 @@ export declare function isJust<A>(self: Maybe<A>): self is Just<A>;
  * @tsplus location "@fncts/base/data/Maybe/definition"
  */
 export declare function isNothing<A>(self: Maybe<A>): self is Nothing;
+/**
+ * @tsplus fluent fncts.Maybe concrete
+ * @tsplus static fncts.MaybeOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/base/data/Maybe/definition"
+ */
+export declare function concrete<A>(self: Maybe<A>): asserts self is Just<A> | Nothing;

package/data/Maybe/instances.d.ts

@@ -1,15 +1,21 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-import * as P from "../../typeclass.js";
-export interface MaybeF extends HKT {
-    readonly type: Maybe<this["A"]>;
-    readonly variance: {
-        readonly A: "-";
-    };
-}
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type * as P from "../../typeclass.js";
+import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 export declare const Functor: P.Functor<MaybeF>;
 export declare const Apply: P.Apply<MaybeF>;
 export declare const Applicative: P.Applicative<MaybeF>;
 export declare const Monad: P.Monad<MaybeF>;
 export declare const Foldable: P.Foldable<MaybeF>;
 export declare const Filterable: P.Filterable<MaybeF>;
+/**
+ * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
+export declare function deriveGuard<A extends Maybe<any>>(...[guard]: [A] extends [Maybe<infer A>] ? [guard: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Maybe]<_> 10
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
+export declare function deriveDecoder<A extends Maybe<any>>(...[value]: [A] extends [Maybe<infer A>] ? [value: Decoder<A>] : never): Decoder<A>;

package/data/Newtype.d.ts

@@ -2,13 +2,12 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Newtype
  */
-export interface Newtype<URI, A, C = HKT.None> {
+export interface Newtype<URI, A> {
     readonly _URI: URI;
-    readonly _A: A;
-    readonly _C: C;
+    readonly [HKT.A]: A;
 }
 export declare namespace Newtype {
-    type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
+    type Iso<N extends NewtypeHKT> = NewtypeIso<N>;
 }
 /**
  * @tsplus type fncts.NewtypeOps
@@ -17,20 +16,20 @@ export interface NewtypeOps {
 }
 export declare const Newtype: NewtypeOps;
 export interface NewtypeHKT extends HKT {
-    readonly type: Newtype<any, any>;
+    readonly [HKT.T]: Newtype<any, any>;
 }
-export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
+export interface NewtypeIso<N extends NewtypeHKT> {
     /**
      * @tsplus macro identity
      */
-    get: <K extends HKT.GetExtends<C, "K", any>, Q extends HKT.GetExtends<C, "Q", any>, W extends HKT.GetExtends<C, "W", any>, X extends HKT.GetExtends<C, "X", any>, I extends HKT.GetExtends<C, "I", any>, S extends HKT.GetExtends<C, "S", any>, R extends HKT.GetExtends<C, "E", any>, E extends HKT.GetExtends<C, "E", any>, A extends HKT.GetExtends<C, "A", any>>(_: HKT.Kind<N, N["type"]["_C"], K, Q, W, X, I, S, R, E, A>["_A"]) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>;
+    get: <K, Q, W, X, I, S, R, E, A>(_: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A]) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>;
     /**
      * @tsplus macro identity
      */
-    reverseGet: <K extends HKT.GetExtends<C, "K", any>, Q extends HKT.GetExtends<C, "Q", any>, W extends HKT.GetExtends<C, "W", any>, X extends HKT.GetExtends<C, "X", any>, I extends HKT.GetExtends<C, "I", any>, S extends HKT.GetExtends<C, "S", any>, R extends HKT.GetExtends<C, "E", any>, E extends HKT.GetExtends<C, "E", any>, A extends HKT.GetExtends<C, "A", any>>(_: HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>["_A"];
+    reverseGet: <K, Q, W, X, I, S, R, E, A>(_: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A];
 }
 /**
  * @tsplus static fncts.NewtypeOps __call
  * @tsplus location "@fncts/base/data/Newtype"
  */
-export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N, N["type"]["_C"]>;
+export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N>;

package/data/Refinement/api.d.ts

@@ -1,10 +1,12 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 /**
  * @tsplus fluent fncts.Refinement and
  * @tsplus operator fncts.Refinement &&
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
 export declare function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C>;
+export declare function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B>;
 /**
  * @tsplus fluent fncts.Refinement contramap
  * @tsplus location "@fncts/base/data/Refinement/api"

package/data/Struct/definition.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 interface StructN extends HKT {
-    readonly type: Struct<this["A"]>;
+    readonly [HKT.T]: Struct<HKT._A<this>>;
 }
 /**
  * @tsplus type fncts.Struct

package/data/These/api.d.ts

@@ -0,0 +1,73 @@
+import { These } from "@fncts/base/data/These";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { Both, Left, Right } from "@fncts/base/data/These/definition";
+import type * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus fluent fncts.These isLeft
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function isLeft<E, A>(self: These<E, A>): self is Left<E>;
+/**
+ * @tsplus fluent fncts.These isRight
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function isRight<E, A>(self: These<E, A>): self is Right<A>;
+/**
+ * @tsplus fluent fncts.These isBoth
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function isBoth<E, A>(self: These<E, A>): self is Both<E, A>;
+/**
+ * @tsplus fluent fncts.These map
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function map<E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B>;
+/**
+ * @tsplus fluent fncts.These mapLeft
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function mapLeft<E, A, E1>(self: These<E, A>, f: (e: E) => E1): These<E1, A>;
+/**
+ * @tsplus fluent fncts.These bimap
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function bimap<E, A, E1, B>(self: These<E, A>, f: (e: E) => E1, g: (a: A) => B): These<E1, B>;
+/**
+ * @tsplus fluent fncts.These zipWith
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function zipWith<E, A, B, C>(self: These<E, A>, that: These<E, B>, f: (a: A, b: B) => C, 
+/** @tsplus auto */ S: P.Semigroup<E>): These<E, C>;
+/**
+ * @tsplus fluent fncts.These zip
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function zip<E, A, B>(self: These<E, A>, that: These<E, B>, 
+/** @tsplus auto */ S: P.Semigroup<E>): These<E, readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.These ap
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function ap<E, A, B>(self: These<E, (a: A) => B>, that: These<E, A>, 
+/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+/**
+ * @tsplus fluent fncts.These flatMap
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function flatMap<E, A, B>(self: These<E, A>, f: (a: A) => These<E, B>, 
+/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+/**
+ * @tsplus fluent fncts.These catchAll
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function catchAll_<E, A, B>(self: These<E, A>, f: (e: E) => These<E, B>): These<E, A | B>;
+/**
+ * @tsplus getter fncts.These condemn
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function condemn<E, A>(self: These<E, A>): These<E, A>;
+/**
+ * @tsplus fluent fncts.These condemnWhen
+ * @tsplus location "@fncts/base/data/These/api"
+ */
+export declare function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A>;

package/data/These/constructors.d.ts

@@ -1,4 +1,5 @@
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus static fncts.TheseOps left
  * @tsplus static fncts.These.Left __call
@@ -17,3 +18,8 @@ export declare function right<E = never, A = never>(a: A): These<E, A>;
  * @tsplus location "@fncts/base/data/These/constructors"
  */
 export declare function both<E = never, A = never>(e: E, a: A): These<E, A>;
+/**
+ * @tsplus static fncts.TheseOps rightOrBoth
+ * @tsplus location "@fncts/base/data/These/constructors"
+ */
+export declare function rightOrBoth<E = never, A = never>(e: Maybe<E>, a: A): These<E, A>;

package/data/These/definition.d.ts

@@ -43,3 +43,8 @@ export declare type These<E, A> = Left<E> | Right<A> | Both<E, A>;
 export interface TheseOps {
 }
 export declare const These: TheseOps;
+/**
+ * @tsplus static fncts.TheseOps isThese
+ * @tsplus location "@fncts/base/data/These/definition"
+ */
+export declare function isThese(u: unknown): u is These<unknown, unknown>;

package/data/These/destructors.d.ts

@@ -1,6 +1,32 @@
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus getter fncts.These right
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function unsafeGetRight<E, A>(self: These<E, A>): A | undefined;
+/**
+ * @tsplus getter fncts.These left
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function unsafeGetLeft<E, A>(self: These<E, A>): E | undefined;
+/**
+ * @tsplus getter fncts.These rightMaybe
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function rightMaybe<E, A>(self: These<E, A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.These leftMaybe
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function leftMaybe<E, A>(self: These<E, A>): Maybe<E>;
 /**
  * @tsplus fluent fncts.These match
  * @tsplus location "@fncts/base/data/These/destructors"
  */
 export declare function match_<E, A, B, C, D>(self: These<E, A>, left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): B | C | D;
+/**
+ * @tsplus fluent fncts.These match2
+ * @tsplus location "@fncts/base/data/These/destructors"
+ */
+export declare function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C;

package/data/These/instances.d.ts

@@ -0,0 +1,13 @@
+import { These } from "@fncts/base/data/These";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus derive fncts.Guard[fncts.These]<_> 10
+ * @tsplus location "@fncts/base/data/These/instances"
+ */
+export declare function deriveGuard<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.These]<_> 10
+ * @tsplus location "@fncts/base/data/These/instances"
+ */
+export declare function deriveDecoder<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never): Decoder<A>;

package/data/These.d.ts

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

package/data/bigint/definition.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    /**
+     * @tsplus type fncts.BigInt
+     */
+    interface BigInt {
+    }
+    /**
+     * @tsplus type fncts.BigIntOps
+     */
+    interface BigIntConstructor {
+    }
+}
+export {};

package/data/bigint/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.BigIntOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/bigint/instances"
+ */
+export declare const Guard: P.Guard<bigint>;

package/data/bigint.d.ts

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

package/data/boolean/definition.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    /**
+     * @tsplus type fncts.Boolean
+     */
+    export interface Boolean {
+    }
+    /**
+     * @tsplus type fncts.BooleanOps
+     */
+    export interface BooleanConstructor {
+    }
+}
+export {};

package/data/boolean/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.BooleanOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/boolean/instances"
+ */
+export declare const Guard: P.Guard<boolean>;

package/data/boolean.d.ts

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

package/data/number/instances.d.ts

@@ -1,11 +1,19 @@
 import * as P from "../../typeclass.js";
 /**
  * @tsplus static fncts.NumberOps Eq
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/number/instances"
  */
 export declare const Eq: P.Eq<number>;
 /**
  * @tsplus static fncts.NumberOps Ord
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/number/instances"
  */
 export declare const Ord: P.Ord<number>;
+/**
+ * @tsplus static fncts.NumberOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/number/instances"
+ */
+export declare const Guard: P.Guard<number>;

package/data/object/instances.d.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus implicit
+ * @tsplus static fncts.globalOps Guard
+ * @tsplus location "@fncts/base/data/object/instances"
+ */
+export declare const Guard: P.Guard<{}>;

package/data/string/instances.d.ts

@@ -1,21 +1,31 @@
 import * as P from "../../typeclass.js";
 /**
  * @tsplus static fncts.StringOps Eq
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Eq: P.Eq<string>;
 /**
  * @tsplus static fncts.StringOps Semigroup
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Semigroup: P.Semigroup<string>;
 /**
  * @tsplus static fncts.StringOps Monoid
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Monoid: P.Monoid<string>;
 /**
  * @tsplus static fncts.StringOps Ord
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/string/instances"
  */
 export declare const Ord: P.Ord<string>;
+/**
+ * @tsplus static fncts.StringOps Guard
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/string/instances"
+ */
+export declare const Guard: P.Guard<string>;

package/internal/Stack.d.ts

@@ -7,6 +7,7 @@ export declare class Stack<A> {
     constructor(node?: Node<A> | undefined);
     clone(): Stack<A>;
     get hasNext(): boolean;
+    get isEmpty(): boolean;
     peek(): A | undefined;
     pop(): A | undefined;
     push(value: A): void;

package/json/EitherJson.d.ts

@@ -0,0 +1,24 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface RightJson<A> {
+    readonly _tag: "Right";
+    readonly right: A;
+}
+export interface LeftJson<E> {
+    readonly _tag: "Left";
+    readonly left: E;
+}
+/**
+ * @tsplus type fncts.EitherJson
+ */
+export declare type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
+/**
+ * @tsplus type fncts.EitherJsonOps
+ */
+export interface EitherJsonOps {
+}
+export declare const EitherJson: EitherJsonOps;
+/**
+ * @tsplus static fncts.EitherJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/EitherJson"
+ */
+export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>>;

package/json/MaybeJson.d.ts

@@ -0,0 +1,23 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface NothingJson {
+    readonly _tag: "Nothing";
+}
+export interface JustJson<A> {
+    readonly _tag: "Just";
+    readonly value: A;
+}
+/**
+ * @tsplus type fncts.MaybeJson
+ */
+export declare type MaybeJson<A> = NothingJson | JustJson<A>;
+/**
+ * @tsplus type fncts.MaybeJsonOps
+ */
+export interface MaybeJsonOps {
+}
+export declare const MaybeJson: MaybeJsonOps;
+/**
+ * @tsplus static fncts.MaybeJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/MaybeJson"
+ */
+export declare function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>>;