@duplojs/utils 1.4.44 → 1.4.46

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.d.ts

@@ -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.
      * 
@@ -209,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/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/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/extended/nullable.d.ts

@@ -42,7 +42,7 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
  * @namespace DPE
  * 
  */
-export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace nullable {

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

@@ -42,7 +42,7 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
  * @namespace DPE
  * 
  */
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace optional {

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

@@ -41,7 +41,7 @@ export interface DataParserRecoverExtended<GenericDefinition extends dataParsers
  * @namespace DPE
  * 
  */
-export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;
 }>>;

package/dist/dataParser/parsers/array/index.d.ts

@@ -8,7 +8,7 @@ export * from "./checkers";
 export interface DataParserArrayCheckerCustom<GenericInput extends unknown[] = unknown[]> {
 }
 export type DataParserArrayCheckers<GenericInput extends unknown[] = unknown[]> = (DataParserArrayCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserArrayCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
+export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers<unknown[]>> {
     readonly element: DataParser;
 }
 export declare const arrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;

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/dataParser/parsers/lazy.d.ts

@@ -6,7 +6,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserLazyCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserLazyCheckers<GenericInput extends unknown = unknown> = (DataParserLazyCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLazyCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers> {
+export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers<unknown>> {
     getter: Memoized<DataParser>;
 }
 export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;

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

@@ -7,7 +7,7 @@ export type LiteralValue = string | number | bigint | undefined | null | boolean
 export interface DataParserLiteralCheckerCustom<GenericInput extends LiteralValue = LiteralValue> {
 }
 export type DataParserLiteralCheckers<GenericInput extends LiteralValue = LiteralValue> = (DataParserLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionLiteral extends DataParserDefinition<DataParserLiteralCheckers> {
+export interface DataParserDefinitionLiteral extends DataParserDefinition<DataParserLiteralCheckers<LiteralValue>> {
     readonly value: readonly LiteralValue[];
 }
 export declare const literalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>>;

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

@@ -6,9 +6,9 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserNullableCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserNullableCheckers<GenericInput extends unknown = unknown> = (DataParserNullableCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserNullableCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionNullable<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserNullableCheckers> {
+export interface DataParserDefinitionNullable<GenericOutput extends unknown = unknown> extends DataParserDefinition<DataParserNullableCheckers> {
     readonly inner: DataParser;
-    readonly coalescingValue: GenericCoalescingValue;
+    readonly coalescingValue: GenericOutput;
 }
 export declare const nullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>>;
 type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | null : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | null> & Kind<typeof nullableKind.definition>);

package/dist/dataParser/parsers/object/index.d.ts

@@ -16,10 +16,10 @@ export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectSha
 export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Input<GenericShape[Prop]>;
 } extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
-export interface DataParserObjectCheckerCustom<GenericInput extends DataParserObjectShape = DataParserObjectShape> {
+export interface DataParserObjectCheckerCustom<GenericInput extends object = object> {
 }
-export type DataParserObjectCheckers<GenericInput extends DataParserObjectShape = DataParserObjectShape> = (DataParserObjectCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserObjectCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionObject extends DataParserDefinition<DataParserObjectCheckers> {
+export type DataParserObjectCheckers<GenericInput extends object = object> = (DataParserObjectCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserObjectCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionObject extends DataParserDefinition<DataParserObjectCheckers<object>> {
     readonly shape: DataParserObjectShape;
     readonly optimizedShape: Memoized<{
         readonly key: string;

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

@@ -6,9 +6,9 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserOptionalCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserOptionalCheckers<GenericInput extends unknown = unknown> = (DataParserOptionalCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserOptionalCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionOptional<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserOptionalCheckers> {
+export interface DataParserDefinitionOptional<GenericOutput extends unknown = unknown> extends DataParserDefinition<DataParserOptionalCheckers> {
     readonly inner: DataParser;
-    readonly coalescingValue: GenericCoalescingValue;
+    readonly coalescingValue: GenericOutput;
 }
 export declare const optionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>>;
 type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | undefined : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof optionalKind.definition>);
@@ -51,7 +51,7 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
  * @namespace DP
  * 
  */
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace optional {

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

@@ -6,7 +6,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserPipeCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserPipeCheckers<GenericInput extends unknown = unknown> = (DataParserPipeCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserPipeCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionPipe extends DataParserDefinition<DataParserPipeCheckers> {
+export interface DataParserDefinitionPipe extends DataParserDefinition<DataParserPipeCheckers<unknown>> {
     readonly input: DataParser;
     readonly output: DataParser;
 }

package/dist/dataParser/parsers/record/index.d.ts

@@ -18,7 +18,7 @@ export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral
 export interface DataParserRecordCheckerCustom<GenericInput extends Record<string, unknown> = Record<string, unknown>> {
 }
 export type DataParserRecordCheckers<GenericInput extends Record<string, unknown> = Record<string, unknown>> = (DataParserRecordCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserRecordCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers> {
+export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers<Record<string, unknown>>> {
     readonly key: DataParserRecordKey;
     readonly value: DataParser;
     readonly requireKey: string[] | null;

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

@@ -41,9 +41,9 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
  * const withString = DP.recover(DP.string(), "fallback");
  * const stringResult = withString.parse(123);
  * 
- * const withCheckers = DP.recover(DP.string(), "fallback", {
- * 	checkers: [DP.checkerRefine((value) => value.length > 0)],
- * });
+ * const withCheckers = DP.recover(DP.string(), "fallback")
+ * 	.addChecker(DP.checkerRefine((value) => value.length > 0));
+ * 
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/recover

package/dist/dataParser/parsers/templateLiteral/index.d.ts

@@ -46,7 +46,7 @@ export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralSha
 export interface DataParserTemplateLiteralCheckerCustom<GenericInput extends string = string> {
 }
 export type DataParserTemplateLiteralCheckers<GenericInput extends string = string> = (DataParserTemplateLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTemplateLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers> {
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers<string>> {
     readonly template: TemplateLiteralShape;
     readonly pattern: RegExp;
 }

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

@@ -7,7 +7,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserTransformCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserTransformCheckers<GenericInput extends unknown = unknown> = (DataParserTransformCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTransformCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers> {
+export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers<unknown>> {
     readonly inner: DataParser;
     theFunction(input: any, error: DataParserError): unknown;
 }

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

@@ -22,7 +22,7 @@ export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRe
 export interface DataParserTupleCheckerCustom<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> {
 }
 export type DataParserTupleCheckers<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> = (DataParserTupleCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTupleCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
+export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers<AnyTuple<unknown>>> {
     readonly shape: TupleShape;
     readonly rest?: DataParser;
 }

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

@@ -7,7 +7,7 @@ export type UnionOptions = readonly [DataParser, ...DataParser[]];
 export interface DataParserUnionCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserUnionCheckers<GenericInput extends unknown = unknown> = (DataParserUnionCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserUnionCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionUnion extends DataParserDefinition<DataParserUnionCheckers> {
+export interface DataParserDefinitionUnion extends DataParserDefinition<DataParserUnionCheckers<unknown>> {
     readonly options: UnionOptions;
 }
 export declare const unionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>>;

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>>;