@fncts/base 0.0.17 → 0.0.19

package/collection/immutable/Vector/internal.d.ts

@@ -40,7 +40,7 @@ export declare const mask = 31;
 /**
  * @internal
  */
-declare type Sizes = number[] | undefined;
+type Sizes = number[] | undefined;
 /** @internal */
 export declare class Node {
     sizes: Sizes;
@@ -176,7 +176,7 @@ export declare function sliceTreeVector<A>(from: number, to: number, tree: Node,
  * @internal
  */
 export declare function zeroOffset(): void;
-declare type FoldCb<Input, State> = (input: Input, state: State, index: number) => boolean;
+type FoldCb<Input, State> = (input: Input, state: State, index: number) => boolean;
 /**
  * This function is a lot like a fold. But the reducer function is
  * supposed to mutate its state instead of returning it. Instead of

package/collection/weak/IterableWeakMap.d.ts

@@ -6,7 +6,7 @@ export declare class IterableWeakMap<K extends object, V> implements Iterable<re
     private refSet;
     private finalizationGroup;
     private static cleanup;
-    constructor(iterable: Iterable<readonly [K, V]>);
+    constructor(iterable?: Iterable<readonly [K, V]>);
     set(this: this, key: K, value: V): this;
     get(this: this, key: K): V | undefined;
     delete(this: this, key: K): boolean;

package/control/Eval/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
 export declare const EvalTypeId: unique symbol;
-export declare type EvalTypeId = typeof EvalTypeId;
+export type EvalTypeId = typeof EvalTypeId;
 export interface EvalF extends HKT {
     type: Eval<this["A"]>;
     variance: {
@@ -47,7 +47,7 @@ export declare class Chain<A, B> implements Eval<B> {
     readonly _A: () => B;
     constructor(self: Eval<A>, f: (a: A) => Eval<B>);
 }
-declare type Concrete = Value<any> | Defer<any> | Chain<any, any>;
+type Concrete = Value<any> | Defer<any> | Chain<any, any>;
 /**
  * @tsplus smart:remove
  */

package/control/Z/definition.d.ts

@@ -13,7 +13,7 @@ export interface ZF extends HKT {
     };
 }
 export declare const ZTypeId: unique symbol;
-export declare type ZTypeId = typeof ZTypeId;
+export type ZTypeId = typeof ZTypeId;
 /**
  * `Z<W, S1, S2, R, E, A>` is a purely functional description of a synchronous computation
  * that requires an environment `R` and an initial state `S1` and may either
@@ -131,14 +131,14 @@ export declare class MapLog<W, S1, S2, R, E, A, W1> extends Z<W1, S1, S2, R, E,
     readonly _tag = ZTag.MapLog;
     constructor(ma: Z<W, S1, S2, R, E, A>, modifyLog: (ws: Conc<W>) => Conc<W1>);
 }
-export declare type Concrete = SucceedNow<any> | Fail<any> | Modify<any, any, any> | Chain<any, any, any, any, any, any, any, any, any, any, any> | Match<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> | Access<any, any, any, any, any, any, any> | Provide<any, any, any, any, any, any> | Defer<any, any, any, any, any, any> | Succeed<any> | Tell<any> | MapLog<any, any, any, any, any, any, any>;
+export type Concrete = SucceedNow<any> | Fail<any> | Modify<any, any, any> | Chain<any, any, any, any, any, any, any, any, any, any, any> | Match<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> | Access<any, any, any, any, any, any, any> | Provide<any, any, any, any, any, any> | Defer<any, any, any, any, any, any> | Succeed<any> | Tell<any> | MapLog<any, any, any, any, any, any, any>;
 /**
  * @tsplus static fncts.control.ZOps concrete
  * @tsplus location "@fncts/base/control/Z/definition"
  */
 export declare function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete;
 export declare const ZErrorTypeId: unique symbol;
-export declare type ZErrorTypeId = typeof ZErrorTypeId;
+export type ZErrorTypeId = typeof ZErrorTypeId;
 export declare class ZError<E> {
     readonly cause: Cause<E>;
     readonly _typeId: ZErrorTypeId;

package/data/Branded/definition.d.ts

@@ -1,36 +1,39 @@
 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]: {
+declare const validSym: unique symbol;
+export declare namespace Brand {
+    type valid = typeof validSym;
+    /**
+     * @tsplus derive nominal
+     */
+    interface Valid<in out A, in out K extends string> {
+        [validSym]: {
             [_ 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]]>;
+    type Type<A extends Validation<any, any>> = A extends Validation<infer A, infer K> ? Validated<A, K> : never;
+    type Validated<A, K extends string> = A & Brand.Valid<A, K>;
+    type IsValidated<P extends Valid<any, any>> = {
+        [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K] ? 0 : 1;
+    }[keyof P[Brand.valid]] extends 0 ? unknown : never;
+    type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
+    type Brands<P> = P extends Valid<any, any> ? Union.IntersectionOf<{
+        [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K] ? K extends string ? Valid<P[Brand.valid][K], K> : never : never;
+    }[keyof P[Brand.valid]]> : unknown;
 }
 /**
- * @tsplus type fncts.Brand
- * @tsplus companion fncts.BrandOps
+ * @tsplus type fncts.Validation
+ * @tsplus companion fncts.ValidationOps
+ * @tsplus derive nominal
  */
-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>>);
+export declare class Validation<in out A, in out K extends string> {
+    readonly validate: Refinement<A, A & Brand.Valid<A, K>>;
+    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>);
 }
 /**
- * @tsplus static fncts.BrandOps __call
+ * @tsplus static fncts.ValidationOps __call
  * @tsplus location "@fncts/base/data/Branded/definition"
  */
-export declare function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K>;
+export declare function makeValidation<A, K extends string>(p: Predicate<A>): Validation<A, K>;
 export {};

package/data/Branded/derivations.d.ts

@@ -1,24 +1,24 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
-import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Validation, Brand } 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>>,
+export declare function deriveGuard<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
+    base: Guard<Brand.Unbranded<A>>,
     brands: {
-        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+        [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][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>>,
+export declare function deriveDecoder<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
+    base: Decoder<Brand.Unbranded<A>>,
     brands: {
-        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+        [K in (keyof A[Brand.valid]) & string]: Validation<A[Brand.valid][K], K>;
     }
 ] : never): Decoder<A>;

package/data/Byte.d.ts

@@ -1 +1 @@
-export declare type Byte = number;
+export type Byte = number;

package/data/CaseClass.d.ts

@@ -4,7 +4,7 @@ import { Equatable } from "@fncts/base/typeclass/Equatable";
 import type { Equals } from "@fncts/typelevel/Any";
 import type { True } from "@fncts/typelevel/Boolean";
 export declare const CaseClassTypeId: unique symbol;
-export declare type CaseClassTypeId = typeof CaseClassTypeId;
+export type CaseClassTypeId = typeof CaseClassTypeId;
 export interface CaseArgs {
     readonly [CaseClassTypeId]: ImmutableArray<string>;
 }

package/data/Cause/definition.d.ts

@@ -5,11 +5,11 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 export declare const CauseTypeId: unique symbol;
-export declare type CauseTypeId = typeof CauseTypeId;
+export type CauseTypeId = typeof CauseTypeId;
 /**
  * @tsplus type fncts.Cause
  */
-export declare type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Then<E> | Both<E> | Stackless<E>;
+export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Then<E> | Both<E> | Stackless<E>;
 /**
  * @tsplus type fncts.CauseOps
  */

package/data/Datum/definition.d.ts

@@ -8,7 +8,7 @@ export declare const enum DatumTag {
     Replete = "Replete"
 }
 export declare const DatumTypeId: unique symbol;
-export declare type DatumTypeId = typeof DatumTypeId;
+export type DatumTypeId = typeof DatumTypeId;
 export interface DatumF extends HKT {
     type: Datum<this["A"]>;
     variance: {
@@ -18,7 +18,7 @@ export interface DatumF extends HKT {
 /**
  * @tsplus type fncts.Datum
  */
-export declare type Datum<A> = Initial | Pending | Refresh<A> | Replete<A>;
+export type Datum<A> = Initial | Pending | Refresh<A> | Replete<A>;
 /**
  * @tsplus type fncts.DatumOps
  */

package/data/DatumEither/definition.d.ts

@@ -12,7 +12,7 @@ export interface DatumEitherF extends HKT {
  * @tsplus type fncts.DatumEither
  * @tsplus no-inherit fncts.Datum
  */
-export declare type DatumEither<E, A> = Datum<Either<E, A>>;
+export type DatumEither<E, A> = Datum<Either<E, A>>;
 /**
  * @tsplus type fncts.DatumEitherOps
  */

package/data/DecodeError/definition.d.ts

@@ -2,7 +2,7 @@ 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 type DecodeErrorTypeId = typeof DecodeErrorTypeId;
 export declare abstract class DecodeError {
     readonly _typeId: DecodeErrorTypeId;
     abstract render: Eval<RoseTree<string>>;

package/data/Decoder/api.d.ts

@@ -8,7 +8,7 @@ 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 decode<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

package/data/Decoder/definition.d.ts

@@ -2,7 +2,7 @@ import { HKT } from "@fncts/typelevel/HKT";
 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 type DecoderTypeId = typeof DecoderTypeId;
 export interface DecoderF extends HKT {
     type: Decoder<this["A"]>;
     variance: {
@@ -12,12 +12,12 @@ export interface DecoderF extends HKT {
 /**
  * @tsplus type fncts.Decoder
  * @tsplus companion fncts.DecoderOps
+ * @tsplus derive nominal
  */
-export declare class Decoder<A> {
+export declare class Decoder<in out A> {
     readonly decode: (input: unknown) => These<DecodeError, A>;
     readonly label: string;
     readonly _typeId: DecoderTypeId;
-    readonly _A: () => A;
     constructor(decode: (input: unknown) => These<DecodeError, A>, label: string);
 }
 /**

package/data/Duration/definition.d.ts

@@ -1,7 +1,7 @@
 import { Equatable } from "@fncts/base/typeclass/Equatable";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 export declare const DurationTypeId: unique symbol;
-export declare type DurationTypeId = typeof DurationTypeId;
+export type DurationTypeId = typeof DurationTypeId;
 /**
  * @tsplus type fncts.Duration
  * @tsplus companion fncts.DurationOps

package/data/Either/definition.d.ts

@@ -4,7 +4,7 @@ export declare const enum EitherTag {
     Right = "Right"
 }
 export declare const EitherTypeId: unique symbol;
-export declare type EitherTypeId = typeof EitherTypeId;
+export type EitherTypeId = typeof EitherTypeId;
 export interface EitherF extends HKT {
     type: Either<this["E"], this["A"]>;
     variance: {

package/data/Either/instances.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { EitherF } from "@fncts/base/data/Either/definition.js";
 import { Either } from "@fncts/base/data/Either/definition";
 import * as P from "../../typeclass.js";

package/data/EitherT/definition.d.ts

@@ -3,7 +3,7 @@ import { Either } from "@fncts/base/data/Either/definition";
 /**
  * @tsplus type fncts.EitherT
  */
-export declare type EitherT<F extends HKT, FC, K, Q, W, X, I, S, R, EF, E, A> = HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>;
+export type EitherT<F extends HKT, FC, K, Q, W, X, I, S, R, EF, E, A> = HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>;
 /**
  * @tsplus type fncts.EitherTOps
  */

package/data/Environment/api.d.ts

@@ -12,7 +12,7 @@ export declare function add<R, H extends S, S = H>(self: Environment<R>, service
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare const empty: import("./definition").Environment<never>;
-declare type Tags<R> = R extends infer S ? Tag<S> : never;
+type Tags<R> = R extends infer S ? Tag<S> : never;
 /**
  * @tsplus fluent fncts.Environment get
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Environment/definition.d.ts

@@ -7,7 +7,7 @@ import { Tag } from "@fncts/base/data/Tag/definition";
  * @tsplus location "@fncts/base/data/Environment/definition"
  */
 export declare const EnvSymbol: unique symbol;
-export declare type EnvSymbol = typeof EnvSymbol;
+export type EnvSymbol = typeof EnvSymbol;
 /**
  * @tsplus type fncts.Environment
  * @tsplus companion fncts.EnvironmentOps

package/data/ExecutionStrategy.d.ts

@@ -26,7 +26,7 @@ export declare function concurrentBounded(fiberBound: number): ConcurrentBounded
 /**
  * @tsplus type fncts.ExecutionStrategy
  */
-export declare type ExecutionStrategy = Sequential | Concurrent | ConcurrentBounded;
+export type ExecutionStrategy = Sequential | Concurrent | ConcurrentBounded;
 /**
  * @tsplus type fncts.ExecutionStrategyOps
  */

package/data/Exit/definition.d.ts

@@ -2,11 +2,11 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import * as P from "../../typeclass.js";
 export declare const ExitTypeId: unique symbol;
-export declare type ExitTypeId = typeof ExitTypeId;
+export type ExitTypeId = typeof ExitTypeId;
 /**
  * @tsplus type fncts.Exit
  */
-export declare type Exit<E, A> = Success<A> | Failure<E>;
+export type Exit<E, A> = Success<A> | Failure<E>;
 /**
  * @tsplus type fncts.ExitOps
  */

package/data/FiberId/definition.d.ts

@@ -3,7 +3,7 @@ import { Equatable } from "@fncts/base/typeclass/Equatable";
 import { TraceElement } from "@fncts/base/data/TraceElement/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 export declare const FiberIdTypeId: unique symbol;
-export declare type FiberIdTypeId = typeof FiberIdTypeId;
+export type FiberIdTypeId = typeof FiberIdTypeId;
 export declare class None implements Hashable, Equatable {
     readonly _typeId: FiberIdTypeId;
     readonly _tag = "None";
@@ -31,14 +31,14 @@ export declare class Composite implements Hashable, Equatable {
 /**
  * @tsplus type fncts.FiberId
  */
-export declare type FiberId = None | Runtime | Composite;
+export type FiberId = None | Runtime | Composite;
 /**
  * @tsplus type fncts.FiberIdOps
  */
 export interface FiberIdOps {
 }
 export declare const FiberId: FiberIdOps;
-declare type RuntimeFiberId = Runtime;
+type RuntimeFiberId = Runtime;
 export declare namespace FiberId {
     type Runtime = RuntimeFiberId;
 }

package/data/Maybe/definition.d.ts

@@ -6,7 +6,7 @@ export declare const enum MaybeTag {
     Nothing = "Nothing"
 }
 export declare const MaybeTypeId: unique symbol;
-export declare type MaybeTypdId = typeof MaybeTypeId;
+export type MaybeTypdId = typeof MaybeTypeId;
 export interface MaybeF extends HKT {
     type: Maybe<this["A"]>;
     variance: {

package/data/Maybe/instances.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 export declare const Functor: P.Functor<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;

package/data/Patch/definition.d.ts

@@ -1,7 +1,7 @@
 import { Has } from "@fncts/base/typeclass/Has";
 import { Tag } from "@fncts/base/data/Tag/definition";
 export declare const PatchTypeId: unique symbol;
-export declare type PatchTypeId = typeof PatchTypeId;
+export type PatchTypeId = typeof PatchTypeId;
 /**
  * @tsplus type fncts.Environment.Patch
  * @tsplus companion fncts.Environment.PatchOps
@@ -37,7 +37,7 @@ export declare class UpdateService<Env, Service> extends Patch<Env & Has<Service
     readonly _tag = "UpdateService";
     constructor(update: (_: Service) => Service, tag: Tag<Service>);
 }
-export declare type Concrete = AddService<any, any> | Compose<any, any, any> | Empty<any> | RemoveService<any, any> | UpdateService<any, any>;
+export type Concrete = AddService<any, any> | Compose<any, any, any> | Empty<any> | RemoveService<any, any> | UpdateService<any, any>;
 /**
  * @tsplus macro remove
  */

package/data/Struct/api.d.ts

@@ -1,10 +1,10 @@
 import type { Union } from "@fncts/typelevel";
 import { Struct } from "./definition.js";
-export declare type EnsureLiteral<N> = string extends N ? never : [N] extends [Union.IntersectionOf<N>] ? N : never;
-export declare type TestLiteral<N> = string extends N ? unknown : [N] extends [Union.IntersectionOf<N>] ? N : unknown;
-export declare type EnsureNonexistentProperty<T, N extends string> = Extract<keyof T, N> extends never ? T : never;
-export declare type EnsureLiteralKeys<O> = string extends keyof O ? never : O;
-export declare type EnsureLiteralTuple<A extends ReadonlyArray<unknown>> = unknown extends {
+export type EnsureLiteral<N> = string extends N ? never : [N] extends [Union.IntersectionOf<N>] ? N : never;
+export type TestLiteral<N> = string extends N ? unknown : [N] extends [Union.IntersectionOf<N>] ? N : unknown;
+export type EnsureNonexistentProperty<T, N extends string> = Extract<keyof T, N> extends never ? T : never;
+export type EnsureLiteralKeys<O> = string extends keyof O ? never : O;
+export type EnsureLiteralTuple<A extends ReadonlyArray<unknown>> = unknown extends {
     [K in keyof A]: A[K] extends string ? TestLiteral<A[K]> : unknown;
 }[number] ? never : A;
 /**

package/data/Tag/definition.d.ts

@@ -1,7 +1,7 @@
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
 export declare const TagTypeId: unique symbol;
-export declare type TagTypeId = typeof TagTypeId;
+export type TagTypeId = typeof TagTypeId;
 /**
  * Tag Encodes capabilities of reading and writing a service T into a generic environment
  *

package/data/These/definition.d.ts

@@ -4,7 +4,7 @@ export declare const enum TheseTag {
     Both = "Both"
 }
 export declare const TheseTypeId: unique symbol;
-export declare type TheseTypeId = typeof TheseTypeId;
+export type TheseTypeId = typeof TheseTypeId;
 /**
  * @tsplus type fncts.These.Left
  */
@@ -36,7 +36,7 @@ export declare class Both<E, A> {
 /**
  * @tsplus type fncts.These
  */
-export declare type These<E, A> = Left<E> | Right<A> | Both<E, A>;
+export type These<E, A> = Left<E> | Right<A> | Both<E, A>;
 /**
  * @tsplus type fncts.TheseOps
  */

package/data/These/instances.d.ts

@@ -1,6 +1,6 @@
 import { These } from "@fncts/base/data/These";
 import { Guard } from "@fncts/base/typeclass/Guard";
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus derive fncts.Guard[fncts.These]<_> 10
  * @tsplus location "@fncts/base/data/These/instances"

package/data/TraceElement/definition.d.ts

@@ -10,7 +10,7 @@ export interface SourceLocation {
 /**
  * @tsplus type fncts.TraceElement
  */
-export declare type TraceElement = NoLocation | SourceLocation;
+export type TraceElement = NoLocation | SourceLocation;
 /**
  * @tsplus type fncts.TraceElementOps
  */

package/data/Zipped.d.ts

@@ -1,6 +1,6 @@
 export declare const ZippedTypeId: unique symbol;
-export declare type ZippedTypeId = typeof ZippedTypeId;
-export declare type Zipped<A extends Array<any>> = Readonly<A> & {
+export type ZippedTypeId = typeof ZippedTypeId;
+export type Zipped<A extends Array<any>> = Readonly<A> & {
     readonly [ZippedTypeId]: ZippedTypeId;
 };
 export declare namespace Zipped {

package/data/exceptions/InterruptedException.d.ts

@@ -1,5 +1,5 @@
 export declare const InterruptedExceptionTypeId: unique symbol;
-export declare type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
+export type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
 export declare class InterruptedException {
     readonly message?: string | undefined;
     readonly _typeId: InterruptedExceptionTypeId;

package/global.d.ts

@@ -105,7 +105,7 @@ import { DatumEither } from "@fncts/base/data/DatumEither/definition";
 /**
  * @tsplus global
  */
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus global
  */

package/json/EitherJson.d.ts

@@ -1,4 +1,4 @@
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface RightJson<A> {
     readonly _tag: "Right";
     readonly right: A;
@@ -10,7 +10,7 @@ export interface LeftJson<E> {
 /**
  * @tsplus type fncts.EitherJson
  */
-export declare type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
+export type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
 /**
  * @tsplus type fncts.EitherJsonOps
  */

package/json/MaybeJson.d.ts

@@ -1,4 +1,4 @@
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface NothingJson {
     readonly _tag: "Nothing";
 }
@@ -9,7 +9,7 @@ export interface JustJson<A> {
 /**
  * @tsplus type fncts.MaybeJson
  */
-export declare type MaybeJson<A> = NothingJson | JustJson<A>;
+export type MaybeJson<A> = NothingJson | JustJson<A>;
 /**
  * @tsplus type fncts.MaybeJsonOps
  */

package/json/TheseJson.d.ts

@@ -1,4 +1,4 @@
-import { Decoder } from "@fncts/base/data/Decoder";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface LeftJson<E> {
     readonly _tag: "Left";
     readonly left: E;
@@ -12,7 +12,7 @@ export interface BothJson<E, A> {
     readonly left: E;
     readonly right: A;
 }
-export declare type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
+export type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
 /**
  * @tsplus type fncts.TheseJsonOps
  */

package/optics/At/definition.d.ts

@@ -5,7 +5,7 @@ import { Lens } from "@fncts/base/optics/Lens";
 export interface At<S, I, A> {
     readonly at: (i: I) => Lens<S, A>;
 }
-export declare type AtMin<S, I, A> = {
+export type AtMin<S, I, A> = {
     readonly get: (i: I) => (s: S) => A;
     readonly set: (i: I) => (s: S, a: A) => S;
 } | At<S, I, A>;

package/optics/Index/definition.d.ts

@@ -5,7 +5,7 @@ import type { Optional } from "@fncts/base/optics/Optional";
 export interface Index<S, I, A> {
     readonly index: (i: I) => Optional<S, A>;
 }
-export declare type IndexMin<S, I, A> = Index<S, I, A>;
+export type IndexMin<S, I, A> = Index<S, I, A>;
 /**
  * @tsplus type fncts.optics.IndexOps
  */

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "dependencies": {
-    "@fncts/typelevel": "0.0.13",
-    "uuid": "^8.3.2"
+    "@fncts/typelevel": "0.0.14",
+    "uuid": "^9.0.0"
   },
   "exports": {
     "./*": {

package/typeclass/Applicative.d.ts

@@ -9,4 +9,4 @@ export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>,
 export interface ApplicativeOps {
 }
 export declare const Applicative: ApplicativeOps;
-export declare type CompatibleApplicative<F extends HKT, FC, A> = Applicative<F, FC> & ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>] ? unknown : ["invalid Applicative instance for", A]);
+export type CompatibleApplicative<F extends HKT, FC, A> = Applicative<F, FC> & ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>] ? unknown : ["invalid Applicative instance for", A]);

package/typeclass/Apply.d.ts

@@ -48,13 +48,13 @@ export declare function sequenceT<F extends HKT, FC = HKT.None>(F: Apply<F, FC>)
 /**
  * @internal
  */
-declare type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<F, P, T, {
+type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<F, P, T, {
     [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]>;
 }>;
 /**
  * @internal
  */
-declare type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixStruct<F, P, T, {
+type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixStruct<F, P, T, {
     [K in keyof KT & number]: HKT.Infer<F, FC, P, KT[K]>;
 }>;
 export {};