@duplojs/utils 1.4.44 → 1.4.45

package/dist/either/nullable/filled.d.ts

@@ -1,14 +1,22 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { nullable } from "./create";
-import { eitherNullableKind } from "./base";
+import { nullableKind } from "./base";
+export declare const nullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-filled", unknown>>;
+/**
+ * @deprecated use nullableFilledKind
+ */
 export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-filled", unknown>>;
-type _EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullable", GenericValue> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableFilledKind.definition>);
-export interface EitherNullableFilled<GenericValue extends unknown = unknown> extends _EitherNullableFilled<GenericValue> {
+type _NullableFilled<GenericValue extends unknown = unknown> = (Right<"nullable", GenericValue> & Kind<typeof nullableKind.definition> & Kind<typeof nullableFilledKind.definition>);
+export interface NullableFilled<GenericValue extends unknown = unknown> extends _NullableFilled<GenericValue> {
 }
-type Either = EitherRight | EitherLeft;
+/**
+ * @deprecated use NullableFilled
+ */
+export type EitherNullableFilled<GenericValue extends unknown = unknown> = NullableFilled<GenericValue>;
+type Either = Right | Left;
 /**
  * Type guard that checks that the nullable Either actually contains a value.
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.nullable(true ? "value" : null);
  * 
  * if (E.isNullableFilled(maybeValue)) {
- * 	// type: E.EitherNullableFilled<"value">
+ * 	// type: E.NullableFilled<"value">
  * }
  * ```
  * 
@@ -30,7 +38,7 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Builds an EitherRight<"nullable"> for a non-null value.
+ * Builds an Right<"nullable"> for a non-null value.
  * 
  * Signature: `nullableFilled(value)` → returns a value
  * 
@@ -39,7 +47,7 @@ type Either = EitherRight | EitherLeft;
  * ```ts
  * const result = E.nullableFilled("value");
  * 
- * // type: E.EitherNullableFilled<"value">
+ * // type: E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullableFilled
@@ -62,7 +70,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsNullableFilled(S.capitalize),
  * );
  * 
- * // type: E.EitherNullableEmpty | "Value"
+ * // type: E.NullableEmpty | "Value"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableFilled
@@ -70,9 +78,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullableFilled<GenericValue>;
-export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableFilled>;
+export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): NullableFilled<GenericValue>;
+export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullableFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, NullableFilled>;
 export {};

package/dist/either/nullable/filled.mjs

@@ -1,12 +1,16 @@
 import { nullable } from './create.mjs';
-import { eitherNullableKind } from './base.mjs';
+import { nullableKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullableFilledKind = createEitherKind("nullable-filled");
+const nullableFilledKind = createEitherKind("nullable-filled");
+/**
+ * @deprecated use nullableFilledKind
+ */
+const eitherNullableFilledKind = nullableFilledKind;
 /**
  * {@include either/isNullableFilled/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullableFilledKind = createEitherKind("nullable-filled");
  * {@include either/whenIsNullableFilled/index.md}
  */
 function nullableFilled(value) {
-    return eitherNullableKind.setTo(eitherNullableFilledKind.setTo(right("nullable", value)));
+    return nullableKind.setTo(nullableFilledKind.setTo(right("nullable", value)));
 }
 function isNullableFilled(input) {
     return isRight(input)
-        && eitherNullableKind.has(input)
-        && eitherNullableFilledKind.has(input);
+        && nullableKind.has(input)
+        && nullableFilledKind.has(input);
 }
 function whenIsNullableFilled(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullableFilled(...args) {
     return either;
 }
 
-export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled };
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, nullableFilledKind, whenIsNullableFilled };

package/dist/either/nullish/base.cjs

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

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

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

package/dist/either/nullish/base.mjs

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

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

@@ -1,5 +1,5 @@
-import { type EitherNullishEmpty, type NullishValue } from "./empty";
-import { type EitherNullishFilled } from "./filled";
+import { type NullishEmpty, type NullishValue } from "./empty";
+import { type NullishFilled } from "./filled";
 /**
  * Transforms a potentially null/undefined value into an Either. Allows propagating presence/absence in a type-safe way.
  * 
@@ -12,7 +12,7 @@ import { type EitherNullishFilled } from "./filled";
  * 
  * const result = E.nullish(mayBeInput);
  * 
- * // type: E.EitherNullishEmpty<undefined> | E.EitherNullishFilled<true>
+ * // type: E.NullishEmpty<undefined> | E.NullishFilled<true>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullish
@@ -20,5 +20,5 @@ import { type EitherNullishFilled } from "./filled";
  * @namespace E
  * 
  */
-export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? EitherNullishEmpty<GenericValue> : EitherNullishFilled<GenericValue>;
-export type Nullish<GenericValue extends unknown> = EitherNullishFilled<GenericValue> | EitherNullishEmpty;
+export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? NullishEmpty<GenericValue> : NullishFilled<GenericValue>;
+export type Nullish<GenericValue extends unknown> = NullishFilled<GenericValue> | NullishEmpty;

package/dist/either/nullish/empty.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 eitherNullishEmptyKind = kind.createEitherKind("nullish-empty");
+const nullishEmptyKind = kind.createEitherKind("nullish-empty");
+/**
+ * @deprecated use nullishEmptyKind
+ */
+const eitherNullishEmptyKind = nullishEmptyKind;
 /**
  * {@include either/isNullishEmpty/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullishEmptyKind = kind.createEitherKind("nullish-empty");
  * {@include either/whenIsNullishEmpty/index.md}
  */
 function nullishEmpty(value = undefined) {
-    return base.eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(create.left("nullish", value)));
+    return base.nullishKind.setTo(nullishEmptyKind.setTo(create.left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return is.isLeft(input)
-        && base.eitherNullishKind.has(input)
-        && eitherNullishEmptyKind.has(input);
+        && base.nullishKind.has(input)
+        && nullishEmptyKind.has(input);
 }
 function whenIsNullishEmpty(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullishEmpty(...args) {
 exports.eitherNullishEmptyKind = eitherNullishEmptyKind;
 exports.isNullishEmpty = isNullishEmpty;
 exports.nullishEmpty = nullishEmpty;
+exports.nullishEmptyKind = nullishEmptyKind;
 exports.whenIsNullishEmpty = whenIsNullishEmpty;

package/dist/either/nullish/empty.d.ts

@@ -1,16 +1,24 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { nullish } from "./create";
-import { eitherNullishKind } from "./base";
+import { nullishKind } from "./base";
 export type NullishValue = null | undefined;
+export declare const nullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-empty", unknown>>;
+/**
+ * @deprecated use nullishEmptyKind
+ */
 export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-empty", unknown>>;
-type _EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = (EitherLeft<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishEmptyKind.definition>);
-export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> extends _EitherNullishEmpty<GenericValue> {
+type _NullishEmpty<GenericValue extends NullishValue = NullishValue> = (Left<"nullish", GenericValue> & Kind<typeof nullishKind.definition> & Kind<typeof nullishEmptyKind.definition>);
+export interface NullishEmpty<GenericValue extends NullishValue = NullishValue> extends _NullishEmpty<GenericValue> {
 }
 /**
- * Type guard detecting an EitherNullishEmpty.
+ * @deprecated use NullishEmpty
+ */
+export type EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = NullishEmpty<GenericValue>;
+/**
+ * Type guard detecting an NullishEmpty.
  * 
  * Signature: `isNullishEmpty(input)` → returns a value
  * 
@@ -20,7 +28,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * const maybeValue = E.nullish(true ? "value" : null);
  * 
  * if (E.isNullishEmpty(maybeValue)) {
- * 	// type: E.EitherNullishEmpty<null>
+ * 	// type: E.NullishEmpty<null>
  * }
  * ```
  * 
@@ -30,7 +38,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * 
  */
 /**
- * Explicitly builds an EitherLeft<"nullish"> with null or undefined.
+ * Explicitly builds an Left<"nullish"> with null or undefined.
  * 
  * Signature: `nullishEmpty(value)` → returns a value
  * 
@@ -39,7 +47,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * ```ts
  * const result = E.nullishEmpty();
  * 
- * // type: E.EitherNullishEmpty<undefined>
+ * // type: E.NullishEmpty<undefined>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullishEmpty
@@ -62,7 +70,7 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * 	E.whenIsNullishEmpty(() => "nullish"),
  * );
  * 
- * // type: "nullish" | E.EitherNullishFilled<"value">
+ * // type: "nullish" | E.NullishFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullishEmpty
@@ -70,10 +78,10 @@ export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishV
  * @namespace E
  * 
  */
-export declare function nullishEmpty<const GenericValue extends NullishValue = undefined>(value?: GenericValue): EitherNullishEmpty<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
+export declare function nullishEmpty<const GenericValue extends NullishValue = undefined>(value?: GenericValue): NullishEmpty<GenericValue>;
+type Either = Right | Left;
+export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullishEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, NullishEmpty>;
 export {};

package/dist/either/nullish/empty.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { nullish } from './create.mjs';
-import { eitherNullishKind } from './base.mjs';
+import { nullishKind } from './base.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullishEmptyKind = createEitherKind("nullish-empty");
+const nullishEmptyKind = createEitherKind("nullish-empty");
+/**
+ * @deprecated use nullishEmptyKind
+ */
+const eitherNullishEmptyKind = nullishEmptyKind;
 /**
  * {@include either/isNullishEmpty/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullishEmptyKind = createEitherKind("nullish-empty");
  * {@include either/whenIsNullishEmpty/index.md}
  */
 function nullishEmpty(value = undefined) {
-    return eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(left("nullish", value)));
+    return nullishKind.setTo(nullishEmptyKind.setTo(left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return isLeft(input)
-        && eitherNullishKind.has(input)
-        && eitherNullishEmptyKind.has(input);
+        && nullishKind.has(input)
+        && nullishEmptyKind.has(input);
 }
 function whenIsNullishEmpty(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullishEmpty(...args) {
     return either;
 }
 
-export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty };
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, nullishEmptyKind, whenIsNullishEmpty };

package/dist/either/nullish/filled.cjs

@@ -8,7 +8,11 @@ var is = require('../right/is.cjs');
 var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
+const nullishFilledKind = kind.createEitherKind("nullish-filled");
+/**
+ * @deprecated use nullishFilledKind
+ */
+const eitherNullishFilledKind = nullishFilledKind;
 /**
  * {@include either/isNullishFilled/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
  * {@include either/whenIsNullishFilled/index.md}
  */
 function nullishFilled(value) {
-    return base.eitherNullishKind.setTo(eitherNullishFilledKind.setTo(create.right("nullish", value)));
+    return base.nullishKind.setTo(nullishFilledKind.setTo(create.right("nullish", value)));
 }
 function isNullishFilled(input) {
     return is.isRight(input)
-        && base.eitherNullishKind.has(input)
-        && base.eitherNullishKind.has(input);
+        && base.nullishKind.has(input)
+        && nullishFilledKind.has(input);
 }
 function whenIsNullishFilled(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullishFilled(...args) {
 exports.eitherNullishFilledKind = eitherNullishFilledKind;
 exports.isNullishFilled = isNullishFilled;
 exports.nullishFilled = nullishFilled;
+exports.nullishFilledKind = nullishFilledKind;
 exports.whenIsNullishFilled = whenIsNullishFilled;

package/dist/either/nullish/filled.d.ts

@@ -1,15 +1,23 @@
-import { type EitherRight } from "../right";
-import { type EitherLeft } from "../left";
+import { type Right } from "../right";
+import { type Left } from "../left";
 import { nullish } from "./create";
 import { type Kind } from "../../common/kind";
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
-import { eitherNullishKind } from "./base";
+import { nullishKind } from "./base";
+export declare const nullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-filled", unknown>>;
+/**
+ * @deprecated use nullishFilledKind
+ */
 export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-filled", unknown>>;
-type _EitherNullishFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishFilledKind.definition>);
-export interface EitherNullishFilled<GenericValue extends unknown = unknown> extends _EitherNullishFilled<GenericValue> {
+type _NullishFilled<GenericValue extends unknown = unknown> = (Right<"nullish", GenericValue> & Kind<typeof nullishKind.definition> & Kind<typeof nullishFilledKind.definition>);
+export interface NullishFilled<GenericValue extends unknown = unknown> extends _NullishFilled<GenericValue> {
 }
 /**
- * Type guard that detects an EitherNullishFilled.
+ * @deprecated use NullishFilled
+ */
+export type EitherNullishFilled<GenericValue extends unknown = unknown> = NullishFilled<GenericValue>;
+/**
+ * Type guard that detects an NullishFilled.
  * 
  * Signature: `isNullishFilled(input)` → returns a value
  * 
@@ -19,7 +27,7 @@ export interface EitherNullishFilled<GenericValue extends unknown = unknown> ext
  * const maybeValue = E.nullish(true ? "value" : null);
  * 
  * if (E.isNullishFilled(maybeValue)) {
- * 	// type: E.EitherNullishFilled<"value">
+ * 	// type: E.NullishFilled<"value">
  * }
  * ```
  * 
@@ -29,7 +37,7 @@ export interface EitherNullishFilled<GenericValue extends unknown = unknown> ext
  * 
  */
 /**
- * Builds an EitherRight<"nullish"> with a non-null/non-undefined value.
+ * Builds an Right<"nullish"> with a non-null/non-undefined value.
  * 
  * Signature: `nullishFilled(value)` → returns a value
  * 
@@ -38,7 +46,7 @@ export interface EitherNullishFilled<GenericValue extends unknown = unknown> ext
  * ```ts
  * const result = E.nullishFilled("string");
  * 
- * // type: E.EitherNullishFilled<"string">
+ * // type: E.NullishFilled<"string">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullishFilled
@@ -61,7 +69,7 @@ export interface EitherNullishFilled<GenericValue extends unknown = unknown> ext
  * 	E.whenIsNullishFilled(S.toUpperCase),
  * );
  * 
- * // type: E.EitherNullishEmpty<null> | "VALUE"
+ * // type: E.NullishEmpty<null> | "VALUE"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullishFilled
@@ -69,10 +77,10 @@ export interface EitherNullishFilled<GenericValue extends unknown = unknown> ext
  * @namespace E
  * 
  */
-export declare function nullishFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullishFilled<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishFilled>;
+export declare function nullishFilled<const GenericValue extends unknown>(value: GenericValue): NullishFilled<GenericValue>;
+type Either = Right | Left;
+export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullishFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>;
-export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, NullishFilled>;
 export {};

package/dist/either/nullish/filled.mjs

@@ -1,12 +1,16 @@
 import { nullish } from './create.mjs';
 import { createEitherKind } from '../kind.mjs';
-import { eitherNullishKind } from './base.mjs';
+import { nullishKind } from './base.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullishFilledKind = createEitherKind("nullish-filled");
+const nullishFilledKind = createEitherKind("nullish-filled");
+/**
+ * @deprecated use nullishFilledKind
+ */
+const eitherNullishFilledKind = nullishFilledKind;
 /**
  * {@include either/isNullishFilled/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullishFilledKind = createEitherKind("nullish-filled");
  * {@include either/whenIsNullishFilled/index.md}
  */
 function nullishFilled(value) {
-    return eitherNullishKind.setTo(eitherNullishFilledKind.setTo(right("nullish", value)));
+    return nullishKind.setTo(nullishFilledKind.setTo(right("nullish", value)));
 }
 function isNullishFilled(input) {
     return isRight(input)
-        && eitherNullishKind.has(input)
-        && eitherNullishKind.has(input);
+        && nullishKind.has(input)
+        && nullishFilledKind.has(input);
 }
 function whenIsNullishFilled(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullishFilled(...args) {
     return either;
 }
 
-export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled };
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, nullishFilledKind, whenIsNullishFilled };

package/dist/either/optional/base.cjs

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

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

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

package/dist/either/optional/base.mjs

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

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

@@ -1,5 +1,5 @@
-import { type EitherOptionalEmpty } from "./empty";
-import { type EitherOptionalFilled } from "./filled";
+import { type OptionalEmpty } from "./empty";
+import { type OptionalFilled } from "./filled";
 /**
  * Wraps an undefined/defined value in an Either, useful for propagating optional fields.
  * 
@@ -10,7 +10,7 @@ import { type EitherOptionalFilled } from "./filled";
  * ```ts
  * const result = E.optional(true ? "value" : undefined);
  * 
- * // type: E.EitherOptionalEmpty | E.EitherOptionalFilled<"value">
+ * // type: E.OptionalEmpty | E.OptionalFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/optional
@@ -18,5 +18,5 @@ import { type EitherOptionalFilled } from "./filled";
  * @namespace E
  * 
  */
-export declare function optional<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends undefined ? EitherOptionalEmpty : EitherOptionalFilled<GenericValue>;
-export type Optional<GenericValue extends unknown> = EitherOptionalFilled<GenericValue> | EitherOptionalEmpty;
+export declare function optional<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends undefined ? OptionalEmpty : OptionalFilled<GenericValue>;
+export type Optional<GenericValue extends unknown> = OptionalFilled<GenericValue> | OptionalEmpty;

package/dist/either/optional/empty.cjs

@@ -7,7 +7,11 @@ var create = require('../left/create.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 
-const eitherOptionalEmptyKind = kind.createEitherKind("optional-empty");
+const optionalEmptyKind = kind.createEitherKind("optional-empty");
+/**
+ * @deprecated use optionalEmptyKind
+ */
+const eitherOptionalEmptyKind = optionalEmptyKind;
 /**
  * {@include either/isOptionalEmpty/index.md}
  */
@@ -18,12 +22,12 @@ const eitherOptionalEmptyKind = kind.createEitherKind("optional-empty");
  * {@include either/whenIsOptionalEmpty/index.md}
  */
 function optionalEmpty() {
-    return base.eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(create.left("optional", undefined)));
+    return base.optionalKind.setTo(optionalEmptyKind.setTo(create.left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return is.isLeft(input)
-        && base.eitherOptionalKind.has(input)
-        && eitherOptionalEmptyKind.has(input);
+        && base.optionalKind.has(input)
+        && optionalEmptyKind.has(input);
 }
 function whenIsOptionalEmpty(...args) {
     if (args.length === 1) {
@@ -49,4 +53,5 @@ function whenIsOptionalEmpty(...args) {
 exports.eitherOptionalEmptyKind = eitherOptionalEmptyKind;
 exports.isOptionalEmpty = isOptionalEmpty;
 exports.optionalEmpty = optionalEmpty;
+exports.optionalEmptyKind = optionalEmptyKind;
 exports.whenIsOptionalEmpty = whenIsOptionalEmpty;