@duplojs/utils 1.4.44 → 1.4.45

package/dist/either/kind.cjs

@@ -5,7 +5,12 @@ var kind = require('../common/kind.cjs');
 const createEitherKind = kind.createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsEither");
-const eitherInformationKind = createEitherKind("information");
+const informationKind = createEitherKind("information");
+/**
+ * @deprecated use informationKind
+ */
+const eitherInformationKind = informationKind;
 
 exports.createEitherKind = createEitherKind;
 exports.eitherInformationKind = eitherInformationKind;
+exports.informationKind = informationKind;

package/dist/either/kind.d.ts

@@ -1,2 +1,6 @@
 export declare const createEitherKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsEither/${GenericName}`, GenericKindValue>>;
+export declare const informationKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/information", string>>;
+/**
+ * @deprecated use informationKind
+ */
 export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/information", string>>;

package/dist/either/kind.mjs

@@ -3,6 +3,10 @@ import { createKindNamespace } from '../common/kind.mjs';
 const createEitherKind = createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsEither");
-const eitherInformationKind = createEitherKind("information");
+const informationKind = createEitherKind("information");
+/**
+ * @deprecated use informationKind
+ */
+const eitherInformationKind = informationKind;
 
-export { createEitherKind, eitherInformationKind };
+export { createEitherKind, eitherInformationKind, informationKind };

package/dist/either/left/create.cjs

@@ -3,13 +3,18 @@
 var wrapValue = require('../../common/wrapValue.cjs');
 var kind = require('../kind.cjs');
 
-const eitherLeftKind = kind.createEitherKind("left");
+const leftKind = kind.createEitherKind("left");
+/**
+ * @deprecated use leftKind
+ */
+const eitherLeftKind = leftKind;
 /**
  * {@include either/left/index.md}
  */
 function left(information, value = undefined) {
-    return eitherLeftKind.setTo(kind.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
+    return leftKind.setTo(kind.informationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherLeftKind = eitherLeftKind;
 exports.left = left;
+exports.leftKind = leftKind;

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

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
 import { type WrappedValue } from "../../common/wrapValue";
-import { eitherInformationKind } from "../kind";
+import { informationKind } from "../kind";
+export declare const leftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/left", unknown>>;
+/**
+ * @deprecated use leftKind
+ */
 export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/left", unknown>>;
-type _EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherLeftKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
-export interface EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherLeft<GenericInformation, GenericValue> {
+type _Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof leftKind.definition> & Kind<typeof informationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
+export interface Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _Left<GenericInformation, GenericValue> {
 }
 /**
- * Builds an EitherLeft by associating mandatory business information (literal string) with a value representing the error. This is the fundamental brick to signal a contextualized failure.
+ * @deprecated use Left
+ */
+export type EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = Left<GenericInformation, GenericValue>;
+/**
+ * Builds an Left by associating mandatory business information (literal string) with a value representing the error. This is the fundamental brick to signal a contextualized failure.
  * 
  * Signature: `left(information, value)` → returns a value
  * 
@@ -26,7 +34,7 @@ export interface EitherLeft<GenericInformation extends string = string, GenericV
  * 	),
  * );
  * 
- * // type: E.EitherRight<"number.positive", number> | E.EitherLeft<"number.notPositive", number>
+ * // type: E.Right<"number.positive", number> | E.Left<"number.notPositive", number>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/left
@@ -34,5 +42,5 @@ export interface EitherLeft<GenericInformation extends string = string, GenericV
  * @namespace E
  * 
  */
-export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): EitherLeft<GenericInformation, GenericValue>;
+export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): Left<GenericInformation, GenericValue>;
 export {};

package/dist/either/left/create.mjs

@@ -1,12 +1,16 @@
 import { wrapValue } from '../../common/wrapValue.mjs';
-import { createEitherKind, eitherInformationKind } from '../kind.mjs';
+import { createEitherKind, informationKind } from '../kind.mjs';
 
-const eitherLeftKind = createEitherKind("left");
+const leftKind = createEitherKind("left");
+/**
+ * @deprecated use leftKind
+ */
+const eitherLeftKind = leftKind;
 /**
  * {@include either/left/index.md}
  */
 function left(information, value = undefined) {
-    return eitherLeftKind.setTo(eitherInformationKind.setTo(wrapValue(value), information));
+    return leftKind.setTo(informationKind.setTo(wrapValue(value), information));
 }
 
-export { eitherLeftKind, left };
+export { eitherLeftKind, left, leftKind };

package/dist/either/left/error.cjs

@@ -3,13 +3,18 @@
 var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherErrorKind = kind.createEitherKind("error");
+const errorKind = kind.createEitherKind("error");
+/**
+ * @deprecated use errorKind
+ */
+const eitherErrorKind = errorKind;
 /**
  * {@include either/error/index.md}
  */
 function error(value) {
-    return eitherErrorKind.setTo(create.left("error", value));
+    return errorKind.setTo(create.left("error", value));
 }
 
 exports.eitherErrorKind = eitherErrorKind;
 exports.error = error;
+exports.errorKind = errorKind;

package/dist/either/left/error.d.ts

@@ -1,11 +1,19 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
+export declare const errorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
+/**
+ * @deprecated use errorKind
+ */
 export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
-type _EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
-export interface EitherError<GenericValue extends unknown = unknown> extends _EitherError<GenericValue> {
+type _Error<GenericValue extends unknown = unknown> = (Left<"error", GenericValue> & Kind<typeof errorKind.definition>);
+export interface Error<GenericValue extends unknown = unknown> extends _Error<GenericValue> {
 }
 /**
- * Handy alias to create an EitherLeft with the info fixed to "error". Useful to signal a generic error without manually providing the info.
+ * @deprecated use Error
+ */
+export type EitherError<GenericValue extends unknown = unknown> = Error<GenericValue>;
+/**
+ * Handy alias to create an Left with the info fixed to "error". Useful to signal a generic error without manually providing the info.
  * 
  * Signature: `error(value)` → returns a value
  * 
@@ -24,7 +32,7 @@ export interface EitherError<GenericValue extends unknown = unknown> extends _Ei
  * 	),
  * );
  * 
- * // type: E.EitherError<string> | E.EitherSuccess<string>
+ * // type: E.Error<string> | E.Success<string>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/error
@@ -32,5 +40,5 @@ export interface EitherError<GenericValue extends unknown = unknown> extends _Ei
  * @namespace E
  * 
  */
-export declare function error<const GenericValue extends unknown>(value: GenericValue): EitherError<GenericValue>;
+export declare function error<const GenericValue extends unknown>(value: GenericValue): Error<GenericValue>;
 export {};

package/dist/either/left/error.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { left } from './create.mjs';
 
-const eitherErrorKind = createEitherKind("error");
+const errorKind = createEitherKind("error");
+/**
+ * @deprecated use errorKind
+ */
+const eitherErrorKind = errorKind;
 /**
  * {@include either/error/index.md}
  */
 function error(value) {
-    return eitherErrorKind.setTo(left("error", value));
+    return errorKind.setTo(left("error", value));
 }
 
-export { eitherErrorKind, error };
+export { eitherErrorKind, error, errorKind };

package/dist/either/left/fail.cjs

@@ -3,13 +3,18 @@
 var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherFailKind = kind.createEitherKind("fail");
+const failKind = kind.createEitherKind("fail");
+/**
+ * @deprecated use failKind
+ */
+const eitherFailKind = failKind;
 /**
  * {@include either/fail/index.md}
  */
 function fail() {
-    return eitherFailKind.setTo(create.left("fail", undefined));
+    return failKind.setTo(create.left("fail", undefined));
 }
 
 exports.eitherFailKind = eitherFailKind;
 exports.fail = fail;
+exports.failKind = failKind;

package/dist/either/left/fail.d.ts

@@ -1,11 +1,19 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
+export declare const failKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
+/**
+ * @deprecated use failKind
+ */
 export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
-type _EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
-export interface EitherFail extends _EitherFail {
+type _Fail = (Left<"fail", never> & Kind<typeof failKind.definition>);
+export interface Fail extends _Fail {
 }
 /**
- * Returns an EitherLeft<"fail", never>: perfect to signal a failure without carrying extra data.
+ * @deprecated use Fail
+ */
+export type EitherFail = Fail;
+/**
+ * Returns an Left<"fail", never>: perfect to signal a failure without carrying extra data.
  * 
  * Signature: `fail()` → returns a value
  * 
@@ -25,7 +33,7 @@ export interface EitherFail extends _EitherFail {
  * 	),
  * );
  * 
- * // type: E.EitherSuccess<number> | E.EitherFail
+ * // type: E.Success<number> | E.Fail
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/fail
@@ -33,5 +41,5 @@ export interface EitherFail extends _EitherFail {
  * @namespace E
  * 
  */
-export declare function fail(): EitherFail;
+export declare function fail(): Fail;
 export {};

package/dist/either/left/fail.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { left } from './create.mjs';
 
-const eitherFailKind = createEitherKind("fail");
+const failKind = createEitherKind("fail");
+/**
+ * @deprecated use failKind
+ */
+const eitherFailKind = failKind;
 /**
  * {@include either/fail/index.md}
  */
 function fail() {
-    return eitherFailKind.setTo(left("fail", undefined));
+    return failKind.setTo(left("fail", undefined));
 }
 
-export { eitherFailKind, fail };
+export { eitherFailKind, fail, failKind };

package/dist/either/left/is.cjs

@@ -8,8 +8,8 @@ var kind = require('../kind.cjs');
  * {@include either/isLeft/index.md}
  */
 function isLeft(input) {
-    return create.eitherLeftKind.has(input)
-        && kind.eitherInformationKind.has(input)
+    return create.leftKind.has(input)
+        && kind.informationKind.has(input)
         && wrapValue.isWrappedValue(input);
 }
 

package/dist/either/left/is.d.ts

@@ -1,6 +1,6 @@
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
 /**
- * Type guard that checks whether a value is an EitherLeft. Ideal to secure an unwrap or trigger an error branch.
+ * Type guard that checks whether a value is an Left. Ideal to secure an unwrap or trigger an error branch.
  * 
  * Signature: `isLeft(input)` → returns a value
  * 
@@ -12,7 +12,7 @@ import { type EitherLeft } from "./create";
  * 	: E.fail();
  * 
  * if (E.isLeft(result)) {
- * 	// type: E.EitherFail
+ * 	// type: E.Fail
  * }
  * ```
  * 
@@ -21,4 +21,4 @@ import { type EitherLeft } from "./create";
  * @namespace E
  * 
  */
-export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherLeft>;
+export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Left>;

package/dist/either/left/is.mjs

@@ -1,13 +1,13 @@
-import { eitherLeftKind } from './create.mjs';
+import { leftKind } from './create.mjs';
 import { isWrappedValue } from '../../common/wrapValue.mjs';
-import { eitherInformationKind } from '../kind.mjs';
+import { informationKind } from '../kind.mjs';
 
 /**
  * {@include either/isLeft/index.md}
  */
 function isLeft(input) {
-    return eitherLeftKind.has(input)
-        && eitherInformationKind.has(input)
+    return leftKind.has(input)
+        && informationKind.has(input)
         && isWrappedValue(input);
 }
 

package/dist/either/left/when.d.ts

@@ -1,7 +1,7 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
 /**
- * Executes a function only when the input is an EitherLeft. Otherwise, the original value is returned as-is.
+ * Executes a function only when the input is an Left. Otherwise, the original value is returned as-is.
  * 
  * **Supported call styles:**
  * - Classic: `whenIsLeft(input, theFunction)` → returns a value
@@ -26,5 +26,5 @@ import { type EitherLeft } from "./create";
  * @namespace E
  * 
  */
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherLeft> | GenericOutput;
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Left>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, Left> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Left>>) => GenericOutput): Exclude<GenericInput, Left> | GenericOutput;

package/dist/either/nullable/base.cjs

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

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

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

package/dist/either/nullable/base.mjs

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

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

@@ -1,5 +1,5 @@
-import { type EitherNullableEmpty } from "./empty";
-import { type EitherNullableFilled } from "./filled";
+import { type NullableEmpty } from "./empty";
+import { type NullableFilled } from "./filled";
 /**
  * Wraps a null or non-null value in an Either, while keeping the information on whether it is filled or empty.
  * 
@@ -10,7 +10,7 @@ import { type EitherNullableFilled } from "./filled";
  * ```ts
  * const result = E.nullable(true ? "value" : null);
  * 
- * // type: E.EitherNullableEmpty | E.EitherNullableFilled<"value">
+ * // type: E.NullableEmpty | E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullable
@@ -18,5 +18,5 @@ import { type EitherNullableFilled } from "./filled";
  * @namespace E
  * 
  */
-export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? EitherNullableEmpty : EitherNullableFilled<GenericValue>;
-export type Nullable<GenericValue extends unknown> = EitherNullableFilled<GenericValue> | EitherNullableEmpty;
+export declare function nullable<const GenericValue extends unknown = null>(value: GenericValue): GenericValue extends null ? NullableEmpty : NullableFilled<GenericValue>;
+export type Nullable<GenericValue extends unknown> = NullableFilled<GenericValue> | NullableEmpty;

package/dist/either/nullable/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 eitherNullableEmptyKind = kind.createEitherKind("nullable-empty");
+const nullableEmptyKind = kind.createEitherKind("nullable-empty");
+/**
+ * @deprecated use nullableEmptyKind
+ */
+const eitherNullableEmptyKind = nullableEmptyKind;
 /**
  * {@include either/isNullableEmpty/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullableEmptyKind = kind.createEitherKind("nullable-empty");
  * {@include either/whenIsNullableEmpty/index.md}
  */
 function nullableEmpty() {
-    return base.eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(create.left("nullable", null)));
+    return base.nullableKind.setTo(nullableEmptyKind.setTo(create.left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return is.isLeft(input)
-        && base.eitherNullableKind.has(input)
-        && eitherNullableEmptyKind.has(input);
+        && base.nullableKind.has(input)
+        && nullableEmptyKind.has(input);
 }
 function whenIsNullableEmpty(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullableEmpty(...args) {
 exports.eitherNullableEmptyKind = eitherNullableEmptyKind;
 exports.isNullableEmpty = isNullableEmpty;
 exports.nullableEmpty = nullableEmpty;
+exports.nullableEmptyKind = nullableEmptyKind;
 exports.whenIsNullableEmpty = whenIsNullableEmpty;

package/dist/either/nullable/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 { nullable } from "./create";
-import { eitherNullableKind } from "./base";
+import { nullableKind } from "./base";
+export declare const nullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-empty", unknown>>;
+/**
+ * @deprecated use nullableEmptyKind
+ */
 export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-empty", unknown>>;
-type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
-export interface EitherNullableEmpty extends _EitherNullableEmpty {
+type _NullableEmpty = (Left<"nullable", null> & Kind<typeof nullableKind.definition> & Kind<typeof nullableEmptyKind.definition>);
+export interface NullableEmpty extends _NullableEmpty {
 }
-type Either = EitherRight | EitherLeft;
 /**
- * Type guard that detects an EitherNullableEmpty.
+ * @deprecated use NullableEmpty
+ */
+export type EitherNullableEmpty = NullableEmpty;
+type Either = Right | Left;
+/**
+ * Type guard that detects an NullableEmpty.
  * 
  * Signature: `isNullableEmpty(input)` → returns a value
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.nullable(true ? "value" : null);
  * 
  * if (E.isNullableEmpty(maybeValue)) {
- * 	// type: E.EitherNullableEmpty
+ * 	// type: E.NullableEmpty
  * }
  * ```
  * 
@@ -30,14 +38,14 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Explicitly builds an EitherLeft<"nullable"> containing null.
+ * Explicitly builds an Left<"nullable"> containing null.
  * 
  * Signature: `nullableEmpty()` → returns a value
  * 
  * ```ts
  * const result = E.nullableEmpty();
  * 
- * // type: E.EitherNullableEmpty
+ * // type: E.NullableEmpty
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/nullableEmpty
@@ -60,7 +68,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsNullableEmpty(() => "nullable"),
  * );
  * 
- * // type: "nullable" | E.EitherNullableFilled<"value">
+ * // type: "nullable" | E.NullableFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableEmpty
@@ -68,9 +76,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function nullableEmpty(): EitherNullableEmpty;
-export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
+export declare function nullableEmpty(): NullableEmpty;
+export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, NullableEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
-export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
-export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, NullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, NullableEmpty>;
 export {};

package/dist/either/nullable/empty.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 { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherNullableEmptyKind = createEitherKind("nullable-empty");
+const nullableEmptyKind = createEitherKind("nullable-empty");
+/**
+ * @deprecated use nullableEmptyKind
+ */
+const eitherNullableEmptyKind = nullableEmptyKind;
 /**
  * {@include either/isNullableEmpty/index.md}
  */
@@ -17,12 +21,12 @@ const eitherNullableEmptyKind = createEitherKind("nullable-empty");
  * {@include either/whenIsNullableEmpty/index.md}
  */
 function nullableEmpty() {
-    return eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(left("nullable", null)));
+    return nullableKind.setTo(nullableEmptyKind.setTo(left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return isLeft(input)
-        && eitherNullableKind.has(input)
-        && eitherNullableEmptyKind.has(input);
+        && nullableKind.has(input)
+        && nullableEmptyKind.has(input);
 }
 function whenIsNullableEmpty(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsNullableEmpty(...args) {
     return either;
 }
 
-export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty };
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, nullableEmptyKind, whenIsNullableEmpty };

package/dist/either/nullable/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 eitherNullableFilledKind = kind.createEitherKind("nullable-filled");
+const nullableFilledKind = kind.createEitherKind("nullable-filled");
+/**
+ * @deprecated use nullableFilledKind
+ */
+const eitherNullableFilledKind = nullableFilledKind;
 /**
  * {@include either/isNullableFilled/index.md}
  */
@@ -19,12 +23,12 @@ const eitherNullableFilledKind = kind.createEitherKind("nullable-filled");
  * {@include either/whenIsNullableFilled/index.md}
  */
 function nullableFilled(value) {
-    return base.eitherNullableKind.setTo(eitherNullableFilledKind.setTo(create.right("nullable", value)));
+    return base.nullableKind.setTo(nullableFilledKind.setTo(create.right("nullable", value)));
 }
 function isNullableFilled(input) {
     return is.isRight(input)
-        && base.eitherNullableKind.has(input)
-        && eitherNullableFilledKind.has(input);
+        && base.nullableKind.has(input)
+        && nullableFilledKind.has(input);
 }
 function whenIsNullableFilled(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsNullableFilled(...args) {
 exports.eitherNullableFilledKind = eitherNullableFilledKind;
 exports.isNullableFilled = isNullableFilled;
 exports.nullableFilled = nullableFilled;
+exports.nullableFilledKind = nullableFilledKind;
 exports.whenIsNullableFilled = whenIsNullableFilled;