@duplojs/utils 1.4.43 → 1.4.45

package/dist/clean/constraint/base.d.ts

@@ -30,13 +30,13 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
      * const result = Between1And10.create(5);
      * 
      * if (E.isRight(result)) {
-     * 	// result : E.EitherRight<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
+     * 	// result : E.Right<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
      * }
      * ```
      * 
      */
-    create<GenericData extends GenericPrimitiveValue>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericData>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
-    create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.EitherRight<"createConstrainedType", (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>)> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    create<GenericData extends GenericPrimitiveValue>(data: GenericData): (DEither.Right<"createConstrainedType", ConstrainedType<GenericName, GenericData>> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.Right<"createConstrainedType", (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>)> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
     /**
      * Creates a constrained value and throws on error.
      * 
@@ -57,7 +57,7 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericPrimitiveValue>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createConstrainedType", ConstrainedType<GenericName, GenericPrimitiveValue>> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
     /**
      * Creates a constrained value from an unknown input and throws on error.
      * 
@@ -107,7 +107,7 @@ export declare class CreateConstrainedTypeError extends CreateConstrainedTypeErr
  * const result = Between1And10.create(5);
  * 
  * if (E.isRight(result)) {
- * 	// result : E.EitherRight<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
+ * 	// result : E.Right<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
  * }
  * 
  * const value = Between1And10.createOrThrow(7);

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -12,7 +12,7 @@ import * as DDataParser from "../../../dataParser";
  * const result = C.Int.create(12);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"int", 12>>
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"int", 12>>
  * }
  * 
  * const value = C.Int.createOrThrow(7);
@@ -41,7 +41,7 @@ export type Int = GetConstraint<typeof Int>;
  * const result = C.Positive.create(4);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"positive", 4>>
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"positive", 4>>
  * }
  * 
  * const value = C.Positive.createOrThrow(10);
@@ -70,7 +70,7 @@ export type Positive = GetConstraint<typeof Positive>;
  * const result = C.Negative.create(-4);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"negative", -4>>
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"negative", -4>>
  * }
  * 
  * const value = C.Negative.createOrThrow(-10);

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -12,7 +12,7 @@ import * as DDataParser from "../../../dataParser";
  * const result = C.Email.create("hello@duplojs.dev");
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"email", "hello@duplojs.dev">>
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"email", "hello@duplojs.dev">>
  * }
  * 
  * const email = C.Email.createOrThrow("a@b.com");
@@ -41,7 +41,7 @@ export type Email = GetConstraint<typeof Email>;
  * const result = C.Url.create("https://duplojs.dev");
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"url", "https://duplojs.dev">>
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"url", "https://duplojs.dev">>
  * }
  * 
  * const url = C.Url.createOrThrow("https://example.com");

package/dist/clean/entity.cjs

@@ -116,6 +116,15 @@ function createEntity(name, getPropertiesDefinition) {
     function is$1(input) {
         return entityKind.has(input) && entityKind.getValue(input) === name;
     }
+    function update(entity, newProperties) {
+        const updatedEntity = {};
+        for (const key in propertiesDefinition) {
+            updatedEntity[key] = newProperties[key] !== undefined
+                ? newProperties[key]
+                : entity[key];
+        }
+        return entityKind.setTo(updatedEntity, name);
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -124,6 +133,7 @@ function createEntity(name, getPropertiesDefinition) {
         map: map$1,
         mapOrThrow,
         is: is$1,
+        update,
     });
 }
 

package/dist/clean/entity.d.ts

@@ -1,4 +1,4 @@
-import { type SimplifyTopLevel, type Kind, type Unwrap, type IsEqual, type IsExtends, type Or, type NeverCoalescing } from "../common";
+import { type SimplifyTopLevel, type Kind, type Unwrap, type IsEqual, type IsExtends, type Or, type NeverCoalescing, type RemoveKind } from "../common";
 import { type GetNewType, type NewTypeHandler } from "./newType";
 import * as DEither from "../either";
 import * as DDataParser from "../dataParser";
@@ -85,7 +85,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * ```
      * 
      */
-    map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
+    map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.Right<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.Left<"createEntityError", DDataParser.DataParserError>);
     /**
      * Validates raw properties and throws on error.
      * 
@@ -112,6 +112,18 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
     * 
     */
     is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
+    /**
+     * Updates an entity by merging typed properties into an existing entity.
+     * 
+     * ```ts
+     * const updated = User.Entity.update(mapped, {
+     * 	name: User.Name.createOrThrow("Bobby"),
+     * 	nick: null,
+     * });
+     * ```
+     * 
+     */
+    update<const GenericEntity extends Entity<GenericName>, const GenericProperties extends Partial<EntityProperties<GenericPropertiesDefinition>>>(entity: GenericEntity, properties: GenericProperties): Entity<GenericName> & DObject.AssignObjects<RemoveKind<GenericEntity>, GenericProperties>;
 }
 declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;
@@ -197,7 +209,7 @@ export interface PropertiesDefinitionParams {
  * });
  * 
  * if (E.isRight(mappedResult)) {
- * 	// mappedResult: E.EitherRight<"createEntity", C.Entity<"User">>
+ * 	// mappedResult: E.Right<"createEntity", C.Entity<"User">>
  * }
  * 
  * ```

package/dist/clean/entity.mjs

@@ -114,6 +114,15 @@ function createEntity(name, getPropertiesDefinition) {
     function is(input) {
         return entityKind.has(input) && entityKind.getValue(input) === name;
     }
+    function update(entity, newProperties) {
+        const updatedEntity = {};
+        for (const key in propertiesDefinition) {
+            updatedEntity[key] = newProperties[key] !== undefined
+                ? newProperties[key]
+                : entity[key];
+        }
+        return entityKind.setTo(updatedEntity, name);
+    }
     return entityHandlerKind.setTo({
         name,
         propertiesDefinition,
@@ -122,6 +131,7 @@ function createEntity(name, getPropertiesDefinition) {
         map: map$1,
         mapOrThrow,
         is,
+        update,
     });
 }
 

package/dist/clean/flag.d.ts

@@ -91,7 +91,7 @@ export interface Flag<GenericName extends string = string, GenericValue extends
  * 		drinkAlcohol,
  * 	),
  * );
- * // E.EitherLeft<"not-major", undefined> | E.EitherRight<"not-thirsty-anymore", undefined>
+ * // E.Left<"not-major", undefined> | E.Right<"not-thirsty-anymore", undefined>
  * 
  * const flagged = User.MajorFlag.append(user, user.age);
  * const value = User.MajorFlag.getValue(flagged);

package/dist/clean/newType.d.ts

@@ -34,8 +34,8 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    create<const GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
-    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.EitherRight<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    create<const GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value and throws on error. Works with raw values or primitives.
      * 
@@ -60,12 +60,12 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * const maybe = UserId.createWithUnknown(unknownValue);
      * 
      * if (E.isRight(maybe)) {
-     * 	// maybe: E.EitherRight<"createNewType", UserId>
+     * 	// maybe: E.Right<"createNewType", UserId>
      * }
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value from an unknown input and throws on error.
      * 
@@ -125,7 +125,7 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
  * const maybe = UserId.createWithUnknown(unknownValue);
  * 
  * if (E.isRight(maybe)) {
- * 	// maybe: E.EitherRight<"createNewType", UserId>
+ * 	// maybe: E.Right<"createNewType", UserId>
  * }
  * 
  * const strictValue = UserId.createWithUnknownOrThrow(unknownValue);

package/dist/clean/primitive/base.d.ts

@@ -14,12 +14,12 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
      * const result = C.String.create("hello");
      * 
      * if (E.isRight(result)) {
-     * 	// result: E.EitherRight<"createNewType", C.Primitive<"hello">>
+     * 	// result: E.Right<"createNewType", C.Primitive<"hello">>
      * }
      * ```
      * 
      */
-    create<GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericData>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createNewType", Primitive<GenericData>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a primitive value and throws on error.
      * 
@@ -36,11 +36,11 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
      * ```ts
      * const unknownValue: unknown = "world";
      * const maybe = C.String.createWithUnknown(unknownValue);
-     * // E.EitherLeft<"createNewTypeError", DataParserError> | E.EitherRight<"createNewType", C.Primitive<string>>
+     * // E.Left<"createNewTypeError", DataParserError> | E.Right<"createNewType", C.Primitive<string>>
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericValue>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createNewType", Primitive<GenericValue>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a primitive value from an unknown input and throws on error.
      * 
@@ -89,7 +89,7 @@ export declare class CreatePrimitiveError extends CreatePrimitiveError_base {
  * const result = C.String.create("hello");
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createNewType", C.Primitive<"hello">>
+ * 	// result: E.Right<"createNewType", C.Primitive<"hello">>
  * }
  * 
  * const value = C.String.createOrThrow("world");
@@ -122,7 +122,7 @@ export type String = ReturnType<typeof String["createWithUnknownOrThrow"]>;
  * const result = C.Number.create(42);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createNewType", C.Primitive<42>>
+ * 	// result: E.Right<"createNewType", C.Primitive<42>>
  * }
  * 
  * const value = C.Number.createOrThrow(7);
@@ -155,7 +155,7 @@ export type Number = ReturnType<typeof Number["createWithUnknownOrThrow"]>;
  * const result = C.BigInt.create(10n);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createNewType", C.Primitive<10n>>
+ * 	// result: E.Right<"createNewType", C.Primitive<10n>>
  * }
  * 
  * const value = C.BigInt.createOrThrow(99n);
@@ -188,7 +188,7 @@ export type BigInt = ReturnType<typeof BigInt["createWithUnknownOrThrow"]>;
  * const result = C.Boolean.create(true);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createNewType", C.Primitive<true>>
+ * 	// result: E.Right<"createNewType", C.Primitive<true>>
  * }
  * 
  * const value = C.Boolean.createOrThrow(false);
@@ -223,7 +223,7 @@ export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
  * const result = C.Date.create(date);
  * 
  * if (E.isRight(result)) {
- * // result: E.EitherRight<"createNewType", C.Primitive<D.TheDate>>
+ * // result: E.Right<"createNewType", C.Primitive<D.TheDate>>
  * }
  * 
  * const value = C.Date.createOrThrow(date);
@@ -258,7 +258,7 @@ export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
  * const result = C.Time.create(theTime);
  * 
  * if (E.isRight(result)) {
- * 	// result: E.EitherRight<"createNewType", C.Primitive<D.TheTime>>
+ * 	// result: E.Right<"createNewType", C.Primitive<D.TheTime>>
  * }
  * 
  * const value = C.Time.createOrThrow(theTime);

package/dist/clean/repository.d.ts

@@ -55,7 +55,7 @@ export interface RepositoryHandler<GenericRepository extends object = object> ex
  * 
  * // Application Layer
  * interface UserRepository {
- * 	findById(id: User.Id): Promise<E.EitherSuccess<User.Entity> | E.EitherFail>;
+ * 	findById(id: User.Id): Promise<E.Success<User.Entity> | E.Fail>;
  * }
  * 
  * const UserRepository = C.createRepository<UserRepository>();

package/dist/clean/useCase.d.ts

@@ -60,7 +60,7 @@ export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies
  * 
  * // Application Layer
  * interface UserRepository {
- * 	findById(id: User.Id): Promise<E.EitherSuccess<User.Entity> | E.EitherFail>;
+ * 	findById(id: User.Id): Promise<E.Success<User.Entity> | E.Fail>;
  * }
  * 
  * const UserRepository = C.createRepository<UserRepository>();

package/dist/common/hasKinds.d.ts

@@ -12,13 +12,13 @@ import { type AnyTuple, type UnionToIntersection } from "./types";
  * Predicate overloads (type guards) narrow the output type.
  * 
  * ```ts
- * const input = E.ok() as E.EitherOk | E.EitherError;
+ * const input = E.ok() as E.Ok | E.Error;
  * 
  * if (hasKinds(input, [
  * 	E.eitherOkKind,
  * 	E.eitherRightKind,
  * ])) {
- * 	// type: E.EitherOk
+ * 	// type: E.Ok
  * }
  * 
  * const result = pipe(
@@ -31,7 +31,7 @@ import { type AnyTuple, type UnionToIntersection } from "./types";
  * 		() => "ok",
  * 	),
  * );
- * // result: "ok" | E.EitherError<unknown>
+ * // result: "ok" | E.Error<unknown>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/common/hasKinds

package/dist/common/hasSomeKinds.d.ts

@@ -12,13 +12,13 @@ import { type AnyTuple } from "./types";
  * Predicate overloads (type guards) narrow the output type.
  * 
  * ```ts
- * const input = E.ok() as E.EitherOk | E.EitherError;
+ * const input = E.ok() as E.Ok | E.Error;
  * 
  * if (hasSomeKinds(input, [
  * 	E.eitherOkKind,
  * 	E.eitherErrorKind,
  * ])) {
- * 	// type: E.EitherOk | E.EitherError
+ * 	// type: E.Ok | E.Error
  * }
  * 
  * const result = pipe(
@@ -31,7 +31,7 @@ import { type AnyTuple } from "./types";
  * 		() => "known",
  * 	),
  * );
- * // result: "known" | E.EitherError<unknown>
+ * // result: "known" | E.Error<unknown>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/common/hasSomeKinds

package/dist/common/path/resolveFrom.d.ts

@@ -24,4 +24,4 @@ import type { AnyTuple } from "../types";
  * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveFrom
  * 
  */
-export declare function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.EitherFail | DEither.EitherSuccess<string>;
+export declare function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.Fail | DEither.Success<string>;

package/dist/common/types/maybeArray.d.ts

@@ -1 +1 @@
-export type MaybeArray<GenericValue extends unknown> = GenericValue | GenericValue[];
+export type MaybeArray<GenericValue extends unknown> = GenericValue | readonly GenericValue[];

package/dist/dataParser/base.d.ts

@@ -67,7 +67,7 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
      * @namespace DP
      * 
      */
-    parse(data: unknown): DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>;
+    parse(data: unknown): DEither.Success<GenericOutput> | DEither.Error<DataParserError>;
     /**
      * The asyncParse() method runs a data parser asynchronously and resolves to an Either with the parsed value or a DataParserError.
      * 
@@ -79,7 +79,7 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
      * @namespace DP
      * 
      */
-    asyncParse(data: unknown): Promise<DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>>;
+    asyncParse(data: unknown): Promise<DEither.Success<GenericOutput> | DEither.Error<DataParserError>>;
     /**
      * The addChecker() method returns a new data parser with one or more additional checkers appended.
      * 

package/dist/dataParser/baseExtended.d.ts

@@ -45,7 +45,7 @@ export interface DataParserExtended<GenericDefinition extends DataParserDefiniti
      * @namespace DPE
      * 
      */
-    parse(data: unknown): DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>;
+    parse(data: unknown): DEither.Success<GenericOutput> | DEither.Error<DataParserError>;
     /**
      * The asyncParse() method runs an extended data parser asynchronously and resolves to an Either with the parsed value or a DataParserError.
      * 
@@ -57,7 +57,7 @@ export interface DataParserExtended<GenericDefinition extends DataParserDefiniti
      * @namespace DPE
      * 
      */
-    asyncParse(data: unknown): Promise<DEither.EitherSuccess<GenericOutput> | DEither.EitherError<DataParserError>>;
+    asyncParse(data: unknown): Promise<DEither.Success<GenericOutput> | DEither.Error<DataParserError>>;
     /**
      * The parseOrThrow() method runs an extended data parser synchronously and returns the parsed value or throws a DataParserThrowError.
      * 

package/dist/dataParser/extended/empty.d.ts

@@ -26,7 +26,7 @@ export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.D
  * const parser = DPE.empty();
  * const result = parser.parse(undefined);
  * if (E.isRight(result)) {
- * 	// E.EitherSuccess<undefined>
+ * 	// E.Success<undefined>
  * }
  * 
  * const coerceParser = DPE.coerce.empty();

package/dist/dataParser/parsers/empty.d.ts

@@ -33,7 +33,7 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
  * const parser = DP.empty();
  * const result = parser.parse(undefined);
  * if (E.isRight(result)) {
- * 	// E.EitherSuccess<undefined>
+ * 	// E.Success<undefined>
  * }
  * 
  * const withCheckers = DP.empty({

package/dist/date/create.d.ts

@@ -2,7 +2,7 @@ import type { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, TheDate
 import * as DEither from "../either";
 import type * as DString from "../string";
 import { type And, type IsEqual, type Not, type IsExtends } from "../common";
-export type MayBe = DEither.EitherRight<"date-created", TheDate> | DEither.EitherLeft<"date-created-error", null>;
+export type MayBe = DEither.Right<"date-created", TheDate> | DEither.Left<"date-created-error", null>;
 type SafeDate = `${number}-${MonthWithDay}`;
 declare const SymbolForbiddenDate: unique symbol;
 type ForbiddenDate<GenericDate extends string> = And<[

package/dist/date/createTime.d.ts

@@ -3,7 +3,7 @@ import { type maxTimeValue, type minTimeValue } from "./constants";
 import { type TheTime, type SpoolingTime } from "./types";
 import * as DEither from "../either";
 import { type IsGreater, type IsLess } from "../number";
-export type MayBeTime = DEither.EitherRight<"time-created", TheTime> | DEither.EitherLeft<"time-created-error", null>;
+export type MayBeTime = DEither.Right<"time-created", TheTime> | DEither.Left<"time-created-error", null>;
 type Units = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
 declare const SymbolForbiddenTime: unique symbol;
 type ForbiddenTime<GenericInput extends number, GenericUnit extends Units> = IsEqual<GenericInput, number> extends true ? {

package/dist/either/bool/base.cjs

@@ -2,6 +2,11 @@
 
 var kind = require('../kind.cjs');
 
-const eitherBoolKind = kind.createEitherKind("bool");
+const boolKind = kind.createEitherKind("bool");
+/**
+ * @deprecated use boolKind
+ */
+const eitherBoolKind = boolKind;
 
+exports.boolKind = boolKind;
 exports.eitherBoolKind = eitherBoolKind;

package/dist/either/bool/base.d.ts

@@ -1 +1,5 @@
+export declare const boolKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/bool", unknown>>;
+/**
+ * @deprecated use boolKind
+ */
 export declare const eitherBoolKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/bool", unknown>>;

package/dist/either/bool/base.mjs

@@ -1,5 +1,9 @@
 import { createEitherKind } from '../kind.mjs';
 
-const eitherBoolKind = createEitherKind("bool");
+const boolKind = createEitherKind("bool");
+/**
+ * @deprecated use boolKind
+ */
+const eitherBoolKind = boolKind;
 
-export { eitherBoolKind };
+export { boolKind, eitherBoolKind };

package/dist/either/bool/create.d.ts

@@ -1,8 +1,8 @@
 import { type FalsyValue, type IsEqual } from "../../common";
-import { type EitherBoolFalsy } from "./falsy";
-import { type EitherBoolTruthy } from "./truthy";
+import { type BoolFalsy } from "./falsy";
+import { type BoolTruthy } from "./truthy";
 /**
- * Converts any value into a boolean monad (EitherBoolTruthy or EitherBoolFalsy). Handy to keep track of the test while benefiting from the whenIsBoolTruthy/whenIsBoolFalsy helpers.
+ * Converts any value into a boolean monad (BoolTruthy or BoolFalsy). Handy to keep track of the test while benefiting from the whenIsBoolTruthy/whenIsBoolFalsy helpers.
  * 
  * Signature: `bool(value)` → returns a value
  * 
@@ -15,7 +15,7 @@ import { type EitherBoolTruthy } from "./truthy";
  * 	E.bool,
  * );
  * 
- * // type: E.EitherBoolFalsy<undefined> | E.EitherBoolTruthy<"nest">
+ * // type: E.BoolFalsy<undefined> | E.BoolTruthy<"nest">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/bool
@@ -23,5 +23,5 @@ import { type EitherBoolTruthy } from "./truthy";
  * @namespace E
  * 
  */
-export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends FalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, bigint> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0n> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;
-export type Bool<GenericValue extends unknown> = EitherBoolTruthy<GenericValue> | EitherBoolFalsy;
+export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends FalsyValue ? BoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? BoolTruthy<GenericValue> | BoolFalsy<0> : IsEqual<GenericValue, bigint> extends true ? BoolTruthy<GenericValue> | BoolFalsy<0n> : IsEqual<GenericValue, string> extends true ? BoolTruthy<GenericValue> | BoolFalsy<""> : BoolTruthy<GenericValue>;
+export type Bool<GenericValue extends unknown> = BoolTruthy<GenericValue> | BoolFalsy;

package/dist/either/bool/falsy.cjs

@@ -8,7 +8,11 @@ var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherBoolFalsyKind = kind.createEitherKind("bool-falsy");
+const boolFalsyKind = kind.createEitherKind("bool-falsy");
+/**
+ * @deprecated use boolFalsyKind
+ */
+const eitherBoolFalsyKind = boolFalsyKind;
 /**
  * {@include either/boolFalsy/index.md}
  */
@@ -19,12 +23,12 @@ const eitherBoolFalsyKind = kind.createEitherKind("bool-falsy");
  * {@include either/whenIsBoolFalsy/index.md}
  */
 function boolFalsy(value = undefined) {
-    return base.eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(create.left("bool", value)));
+    return base.boolKind.setTo(boolFalsyKind.setTo(create.left("bool", value)));
 }
 function isBoolFalsy(input) {
     return is.isLeft(input)
-        && base.eitherBoolKind.has(input)
-        && eitherBoolFalsyKind.has(input);
+        && base.boolKind.has(input)
+        && boolFalsyKind.has(input);
 }
 function whenIsBoolFalsy(...args) {
     if (args.length === 1) {
@@ -48,6 +52,7 @@ function whenIsBoolFalsy(...args) {
 }
 
 exports.boolFalsy = boolFalsy;
+exports.boolFalsyKind = boolFalsyKind;
 exports.eitherBoolFalsyKind = eitherBoolFalsyKind;
 exports.isBoolFalsy = isBoolFalsy;
 exports.whenIsBoolFalsy = whenIsBoolFalsy;