@duplojs/utils 1.4.44 → 1.4.46

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;

package/dist/either/optional/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 { eitherOptionalKind } from "./base";
+import { optionalKind } from "./base";
 import { optional } from "./create";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
+export declare const optionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/optional-empty", unknown>>;
+/**
+ * @deprecated use optionalEmptyKind
+ */
 export declare const eitherOptionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/optional-empty", unknown>>;
-type _EitherOptionalEmpty = (EitherLeft<"optional", undefined> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalEmptyKind.definition>);
-export interface EitherOptionalEmpty extends _EitherOptionalEmpty {
+type _OptionalEmpty = (Left<"optional", undefined> & Kind<typeof optionalKind.definition> & Kind<typeof optionalEmptyKind.definition>);
+export interface OptionalEmpty extends _OptionalEmpty {
 }
-type Either = EitherRight | EitherLeft;
 /**
- * Type guard that detects an EitherOptionalEmpty.
+ * @deprecated use OptionalEmpty
+ */
+export type EitherOptionalEmpty = OptionalEmpty;
+type Either = Right | Left;
+/**
+ * Type guard that detects an OptionalEmpty.
  * 
  * Signature: `isOptionalEmpty(input)` → returns a value
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.optional(true ? "value" : undefined);
  * 
  * if (E.isOptionalEmpty(maybeValue)) {
- * 	// type: E.EitherOptionalEmpty
+ * 	// type: E.OptionalEmpty
  * }
  * ```
  * 
@@ -30,14 +38,14 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Builds an EitherLeft<"optional"> containing undefined.
+ * Builds an Left<"optional"> containing undefined.
  * 
  * Signature: `optionalEmpty()` → returns a value
  * 
  * ```ts
  * const result = E.optionalEmpty();
  * 
- * // type: E.EitherOptionalEmpty
+ * // type: E.OptionalEmpty
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/optionalEmpty
@@ -60,7 +68,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsOptionalEmpty(() => "empty"),
  * );
  * 
- * // type: E.EitherOptionalFilled<"value"> | "empty"
+ * // type: E.OptionalFilled<"value"> | "empty"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsOptionalEmpty
@@ -68,9 +76,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function optionalEmpty(): EitherOptionalEmpty;
-export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
+export declare function optionalEmpty(): OptionalEmpty;
+export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, OptionalEmpty>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>;
-export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, OptionalEmpty>;
 export {};

package/dist/either/optional/empty.mjs

@@ -1,11 +1,15 @@
 import { createEitherKind } from '../kind.mjs';
-import { eitherOptionalKind } from './base.mjs';
+import { optionalKind } from './base.mjs';
 import { optional } from './create.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 
-const eitherOptionalEmptyKind = createEitherKind("optional-empty");
+const optionalEmptyKind = createEitherKind("optional-empty");
+/**
+ * @deprecated use optionalEmptyKind
+ */
+const eitherOptionalEmptyKind = optionalEmptyKind;
 /**
  * {@include either/isOptionalEmpty/index.md}
  */
@@ -16,12 +20,12 @@ const eitherOptionalEmptyKind = createEitherKind("optional-empty");
  * {@include either/whenIsOptionalEmpty/index.md}
  */
 function optionalEmpty() {
-    return eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(left("optional", undefined)));
+    return optionalKind.setTo(optionalEmptyKind.setTo(left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return isLeft(input)
-        && eitherOptionalKind.has(input)
-        && eitherOptionalEmptyKind.has(input);
+        && optionalKind.has(input)
+        && optionalEmptyKind.has(input);
 }
 function whenIsOptionalEmpty(...args) {
     if (args.length === 1) {
@@ -44,4 +48,4 @@ function whenIsOptionalEmpty(...args) {
     return either;
 }
 
-export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty };
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, optionalEmptyKind, whenIsOptionalEmpty };

package/dist/either/optional/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 eitherOptionalFilledKind = kind.createEitherKind("optional-filled");
+const optionalFilledKind = kind.createEitherKind("optional-filled");
+/**
+ * @deprecated use optionalFilledKind
+ */
+const eitherOptionalFilledKind = optionalFilledKind;
 /**
  * {@include either/isOptionalFilled/index.md}
  */
@@ -19,12 +23,12 @@ const eitherOptionalFilledKind = kind.createEitherKind("optional-filled");
  * {@include either/whenIsOptionalFilled/index.md}
  */
 function optionalFilled(value) {
-    return base.eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(create.right("optional", value)));
+    return base.optionalKind.setTo(optionalFilledKind.setTo(create.right("optional", value)));
 }
 function isOptionalFilled(input) {
     return is.isRight(input)
-        && base.eitherOptionalKind.has(input)
-        && eitherOptionalFilledKind.has(input);
+        && base.optionalKind.has(input)
+        && optionalFilledKind.has(input);
 }
 function whenIsOptionalFilled(...args) {
     if (args.length === 1) {
@@ -50,4 +54,5 @@ function whenIsOptionalFilled(...args) {
 exports.eitherOptionalFilledKind = eitherOptionalFilledKind;
 exports.isOptionalFilled = isOptionalFilled;
 exports.optionalFilled = optionalFilled;
+exports.optionalFilledKind = optionalFilledKind;
 exports.whenIsOptionalFilled = whenIsOptionalFilled;

package/dist/either/optional/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 { eitherOptionalKind } from "./base";
+import { optionalKind } from "./base";
 import { optional } from "./create";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
+export declare const optionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/optional-filled", unknown>>;
+/**
+ * @deprecated use optionalFilledKind
+ */
 export declare const eitherOptionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/optional-filled", unknown>>;
-type _EitherOptionalFilled<GenericValue extends unknown = unknown> = (EitherRight<"optional", GenericValue> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalFilledKind.definition>);
-export interface EitherOptionalFilled<GenericValue extends unknown = unknown> extends _EitherOptionalFilled<GenericValue> {
+type _OptionalFilled<GenericValue extends unknown = unknown> = (Right<"optional", GenericValue> & Kind<typeof optionalKind.definition> & Kind<typeof optionalFilledKind.definition>);
+export interface OptionalFilled<GenericValue extends unknown = unknown> extends _OptionalFilled<GenericValue> {
 }
-type Either = EitherRight | EitherLeft;
+/**
+ * @deprecated use OptionalFilled
+ */
+export type EitherOptionalFilled<GenericValue extends unknown = unknown> = OptionalFilled<GenericValue>;
+type Either = Right | Left;
 /**
  * Type guard that checks that an optional contains a value.
  * 
@@ -20,7 +28,7 @@ type Either = EitherRight | EitherLeft;
  * const maybeValue = E.optional(true ? "value" : undefined);
  * 
  * if (E.isOptionalFilled(maybeValue)) {
- * 	// type: E.EitherOptionalFilled<"value">
+ * 	// type: E.OptionalFilled<"value">
  * }
  * ```
  * 
@@ -30,7 +38,7 @@ type Either = EitherRight | EitherLeft;
  * 
  */
 /**
- * Builds an EitherRight<"optional"> when the value is defined.
+ * Builds an Right<"optional"> when the value is defined.
  * 
  * Signature: `optionalFilled(value)` → returns a value
  * 
@@ -39,7 +47,7 @@ type Either = EitherRight | EitherLeft;
  * ```ts
  * const result = E.optionalFilled("value");
  * 
- * // type: E.EitherOptionalFilled<"value">
+ * // type: E.OptionalFilled<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/optionalFilled
@@ -62,7 +70,7 @@ type Either = EitherRight | EitherLeft;
  * 	E.whenIsOptionalFilled(S.capitalize),
  * );
  * 
- * // type: E.EitherOptionalEmpty | "Value"
+ * // type: E.OptionalEmpty | "Value"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsOptionalFilled
@@ -70,9 +78,9 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): EitherOptionalFilled<GenericValue>;
-export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalFilled>;
+export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): OptionalFilled<GenericValue>;
+export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, OptionalFilled>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>;
-export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, OptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, OptionalFilled>;
 export {};

package/dist/either/optional/filled.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
-import { eitherOptionalKind } from './base.mjs';
+import { optionalKind } from './base.mjs';
 import { optional } from './create.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 eitherOptionalFilledKind = createEitherKind("optional-filled");
+const optionalFilledKind = createEitherKind("optional-filled");
+/**
+ * @deprecated use optionalFilledKind
+ */
+const eitherOptionalFilledKind = optionalFilledKind;
 /**
  * {@include either/isOptionalFilled/index.md}
  */
@@ -17,12 +21,12 @@ const eitherOptionalFilledKind = createEitherKind("optional-filled");
  * {@include either/whenIsOptionalFilled/index.md}
  */
 function optionalFilled(value) {
-    return eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(right("optional", value)));
+    return optionalKind.setTo(optionalFilledKind.setTo(right("optional", value)));
 }
 function isOptionalFilled(input) {
     return isRight(input)
-        && eitherOptionalKind.has(input)
-        && eitherOptionalFilledKind.has(input);
+        && optionalKind.has(input)
+        && optionalFilledKind.has(input);
 }
 function whenIsOptionalFilled(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsOptionalFilled(...args) {
     return either;
 }
 
-export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled };
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, optionalFilledKind, whenIsOptionalFilled };

package/dist/either/right/asyncGroup.d.ts

@@ -1,12 +1,12 @@
 import { type AnyFunction, type SimplifyTopLevel, type MayBeGetter, type Unwrap, type MaybePromise } from "../../common";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "./create";
+import { type Left } from "../left";
+import { type Right } from "./create";
 import * as DEither from "..";
-type Either = MaybePromise<EitherRight | EitherLeft>;
-type ComputeResult<GenericGroup extends Record<string, MayBeGetter<Either>>> = Promise<DEither.EitherSuccess<SimplifyTopLevel<{
-    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Unwrap<Extract<Awaited<ReturnType<GenericGroup[Prop]>>, EitherRight>> : Unwrap<Extract<Awaited<GenericGroup[Prop]>, EitherRight>>;
+type Either = MaybePromise<Right | Left>;
+type ComputeResult<GenericGroup extends Record<string, MayBeGetter<Either>>> = Promise<DEither.Success<SimplifyTopLevel<{
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Unwrap<Extract<Awaited<ReturnType<GenericGroup[Prop]>>, Right>> : Unwrap<Extract<Awaited<GenericGroup[Prop]>, Right>>;
 }>> | {
-    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Extract<Awaited<ReturnType<GenericGroup[Prop]>>, EitherLeft> : Extract<Awaited<GenericGroup[Prop]>, EitherLeft>;
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Extract<Awaited<ReturnType<GenericGroup[Prop]>>, Left> : Extract<Awaited<GenericGroup[Prop]>, Left>;
 }[keyof GenericGroup]>;
 /**
  * The asyncGroup() function runs synchronous or asynchronous Either values in parallel (promises, Future) and returns the first Left encountered. If all are Right, it aggregates their values into a typed object.
@@ -26,7 +26,7 @@ type ComputeResult<GenericGroup extends Record<string, MayBeGetter<Either>>> = P
  * 	profile: promiseProfile,
  * });
  * 
- * // type: E.EitherFutureError
+ * // type: E.FutureError
  * ```
  * 
  * @remarks