@duplojs/utils 1.3.32 → 1.4.33

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

@@ -1,2 +1,24 @@
 import { type EitherLeft } from "./create";
+/**
+ * Type guard that checks whether a value is an EitherLeft. Ideal to secure an unwrap or trigger an error branch.
+ * 
+ * Signature: `isLeft(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const result = false
+ * 	? E.ok()
+ * 	: E.fail();
+ * 
+ * if (E.isLeft(result)) {
+ * 	// type: E.EitherFail
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isLeft
+ * 
+ * @namespace E
+ * 
+ */
 export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherLeft>;

package/dist/either/left/is.mjs

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

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

@@ -1,4 +1,30 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "./create";
+/**
+ * Executes a function only when the input is an EitherLeft. Otherwise, the original value is returned as-is.
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsLeft(input, theFunction)` → returns a value
+ * - Curried: `whenIsLeft(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * pipe(
+ * 	true
+ * 		? E.success("true")
+ * 		: E.error("false"),
+ * 
+ * 	E.whenIsLeft((value) => {
+ * 		// type: "false"
+ * 	}),
+ * );
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsLeft
+ * 
+ * @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;

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

@@ -1,4 +1,22 @@
 import { type EitherNullableEmpty } from "./empty";
 import { type EitherNullableFilled } from "./filled";
+/**
+ * Wraps a null or non-null value in an Either, while keeping the information on whether it is filled or empty.
+ * 
+ * Signature: `nullable(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = E.nullable(true ? "value" : null);
+ * 
+ * // type: E.EitherNullableEmpty | E.EitherNullableFilled<"value">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullable
+ * 
+ * @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;

package/dist/either/nullable/empty.cjs

@@ -9,6 +9,15 @@ var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
 const eitherNullableEmptyKind = kind.createEitherKind("nullable-empty");
+/**
+ * {@include either/isNullableEmpty/index.md}
+ */
+/**
+ * {@include either/nullableEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsNullableEmpty/index.md}
+ */
 function nullableEmpty() {
     return base.eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(create.left("nullable", null)));
 }

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

@@ -9,6 +9,65 @@ type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNu
 export interface EitherNullableEmpty extends _EitherNullableEmpty {
 }
 type Either = EitherRight | EitherLeft;
+/**
+ * Type guard that detects an EitherNullableEmpty.
+ * 
+ * Signature: `isNullableEmpty(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const maybeValue = E.nullable(true ? "value" : null);
+ * 
+ * if (E.isNullableEmpty(maybeValue)) {
+ * 	// type: E.EitherNullableEmpty
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isNullableEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Explicitly builds an EitherLeft<"nullable"> containing null.
+ * 
+ * Signature: `nullableEmpty()` → returns a value
+ * 
+ * ```ts
+ * const result = E.nullableEmpty();
+ * 
+ * // type: E.EitherNullableEmpty
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullableEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Executes a callback only when the Either is NullableEmpty.
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsNullableEmpty(input, theFunction)` → returns a value
+ * - Curried: `whenIsNullableEmpty(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * const result = pipe(
+ * 	E.nullable(true ? "value" : null),
+ * 	E.whenIsNullableEmpty(() => "nullable"),
+ * );
+ * 
+ * // type: "nullable" | E.EitherNullableFilled<"value">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableEmpty
+ * 
+ * @namespace E
+ * 
+ */
 export declare function nullableEmpty(): EitherNullableEmpty;
 export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;

package/dist/either/nullable/empty.mjs

@@ -7,6 +7,15 @@ import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
 const eitherNullableEmptyKind = createEitherKind("nullable-empty");
+/**
+ * {@include either/isNullableEmpty/index.md}
+ */
+/**
+ * {@include either/nullableEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsNullableEmpty/index.md}
+ */
 function nullableEmpty() {
     return eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(left("nullable", null)));
 }

package/dist/either/nullable/filled.cjs

@@ -9,6 +9,15 @@ var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
 const eitherNullableFilledKind = kind.createEitherKind("nullable-filled");
+/**
+ * {@include either/isNullableFilled/index.md}
+ */
+/**
+ * {@include either/nullableFilled/index.md}
+ */
+/**
+ * {@include either/whenIsNullableFilled/index.md}
+ */
 function nullableFilled(value) {
     return base.eitherNullableKind.setTo(eitherNullableFilledKind.setTo(create.right("nullable", value)));
 }

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

@@ -9,6 +9,67 @@ type _EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRigh
 export interface EitherNullableFilled<GenericValue extends unknown = unknown> extends _EitherNullableFilled<GenericValue> {
 }
 type Either = EitherRight | EitherLeft;
+/**
+ * Type guard that checks that the nullable Either actually contains a value.
+ * 
+ * Signature: `isNullableFilled(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const maybeValue = E.nullable(true ? "value" : null);
+ * 
+ * if (E.isNullableFilled(maybeValue)) {
+ * 	// type: E.EitherNullableFilled<"value">
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isNullableFilled
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Builds an EitherRight<"nullable"> for a non-null value.
+ * 
+ * Signature: `nullableFilled(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = E.nullableFilled("value");
+ * 
+ * // type: E.EitherNullableFilled<"value">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullableFilled
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Applies a function only when the nullable Either contains a value (NullableFilled).
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsNullableFilled(input, theFunction)` → returns a value
+ * - Curried: `whenIsNullableFilled(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * const result = pipe(
+ * 	E.nullable(true ? "value" : null),
+ * 	E.whenIsNullableFilled(S.capitalize),
+ * );
+ * 
+ * // type: E.EitherNullableEmpty | "Value"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullableFilled
+ * 
+ * @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>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;

package/dist/either/nullable/filled.mjs

@@ -7,6 +7,15 @@ import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
 const eitherNullableFilledKind = createEitherKind("nullable-filled");
+/**
+ * {@include either/isNullableFilled/index.md}
+ */
+/**
+ * {@include either/nullableFilled/index.md}
+ */
+/**
+ * {@include either/whenIsNullableFilled/index.md}
+ */
 function nullableFilled(value) {
     return eitherNullableKind.setTo(eitherNullableFilledKind.setTo(right("nullable", value)));
 }

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

@@ -1,4 +1,24 @@
 import { type EitherNullishEmpty, type NullishValue } from "./empty";
 import { type EitherNullishFilled } from "./filled";
+/**
+ * Transforms a potentially null/undefined value into an Either. Allows propagating presence/absence in a type-safe way.
+ * 
+ * Signature: `nullish(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const mayBeInput = true ? true : undefined;
+ * 
+ * const result = E.nullish(mayBeInput);
+ * 
+ * // type: E.EitherNullishEmpty<undefined> | E.EitherNullishFilled<true>
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullish
+ * 
+ * @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;

package/dist/either/nullish/empty.cjs

@@ -9,6 +9,15 @@ var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
 const eitherNullishEmptyKind = kind.createEitherKind("nullish-empty");
+/**
+ * {@include either/isNullishEmpty/index.md}
+ */
+/**
+ * {@include either/nullishEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsNullishEmpty/index.md}
+ */
 function nullishEmpty(value = undefined) {
     return base.eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(create.left("nullish", value)));
 }

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

@@ -9,6 +9,67 @@ export declare const eitherNullishEmptyKind: import("../../common").KindHandler<
 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 guard detecting an EitherNullishEmpty.
+ * 
+ * Signature: `isNullishEmpty(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const maybeValue = E.nullish(true ? "value" : null);
+ * 
+ * if (E.isNullishEmpty(maybeValue)) {
+ * 	// type: E.EitherNullishEmpty<null>
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isNullishEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Explicitly builds an EitherLeft<"nullish"> with null or undefined.
+ * 
+ * Signature: `nullishEmpty(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = E.nullishEmpty();
+ * 
+ * // type: E.EitherNullishEmpty<undefined>
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullishEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Applies a callback only when the Either is NullishEmpty.
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsNullishEmpty(input, theFunction)` → returns a value
+ * - Curried: `whenIsNullishEmpty(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * const result = pipe(
+ * 	E.nullish(true ? "value" : null),
+ * 	E.whenIsNullishEmpty(() => "nullish"),
+ * );
+ * 
+ * // type: "nullish" | E.EitherNullishFilled<"value">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullishEmpty
+ * 
+ * @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>;

package/dist/either/nullish/empty.mjs

@@ -7,6 +7,15 @@ import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
 const eitherNullishEmptyKind = createEitherKind("nullish-empty");
+/**
+ * {@include either/isNullishEmpty/index.md}
+ */
+/**
+ * {@include either/nullishEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsNullishEmpty/index.md}
+ */
 function nullishEmpty(value = undefined) {
     return eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(left("nullish", value)));
 }

package/dist/either/nullish/filled.cjs

@@ -9,6 +9,15 @@ var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
 const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
+/**
+ * {@include either/isNullishFilled/index.md}
+ */
+/**
+ * {@include either/nullishFilled/index.md}
+ */
+/**
+ * {@include either/whenIsNullishFilled/index.md}
+ */
 function nullishFilled(value) {
     return base.eitherNullishKind.setTo(eitherNullishFilledKind.setTo(create.right("nullish", value)));
 }

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

@@ -8,6 +8,67 @@ export declare const eitherNullishFilledKind: import("../../common").KindHandler
 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 guard that detects an EitherNullishFilled.
+ * 
+ * Signature: `isNullishFilled(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const maybeValue = E.nullish(true ? "value" : null);
+ * 
+ * if (E.isNullishFilled(maybeValue)) {
+ * 	// type: E.EitherNullishFilled<"value">
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isNullishFilled
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Builds an EitherRight<"nullish"> with a non-null/non-undefined value.
+ * 
+ * Signature: `nullishFilled(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = E.nullishFilled("string");
+ * 
+ * // type: E.EitherNullishFilled<"string">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/nullishFilled
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Executes a callback only when the Either contains a defined value (NullishFilled).
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsNullishFilled(input, theFunction)` → returns a value
+ * - Curried: `whenIsNullishFilled(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * const result = pipe(
+ * 	E.nullish(true ? "value" : null),
+ * 	E.whenIsNullishFilled(S.toUpperCase),
+ * );
+ * 
+ * // type: E.EitherNullishEmpty<null> | "VALUE"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsNullishFilled
+ * 
+ * @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>;

package/dist/either/nullish/filled.mjs

@@ -7,6 +7,15 @@ import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
 const eitherNullishFilledKind = createEitherKind("nullish-filled");
+/**
+ * {@include either/isNullishFilled/index.md}
+ */
+/**
+ * {@include either/nullishFilled/index.md}
+ */
+/**
+ * {@include either/whenIsNullishFilled/index.md}
+ */
 function nullishFilled(value) {
     return eitherNullishKind.setTo(eitherNullishFilledKind.setTo(right("nullish", value)));
 }

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

@@ -1,4 +1,22 @@
 import { type EitherOptionalEmpty } from "./empty";
 import { type EitherOptionalFilled } from "./filled";
+/**
+ * Wraps an undefined/defined value in an Either, useful for propagating optional fields.
+ * 
+ * Signature: `optional(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = E.optional(true ? "value" : undefined);
+ * 
+ * // type: E.EitherOptionalEmpty | E.EitherOptionalFilled<"value">
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/optional
+ * 
+ * @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;

package/dist/either/optional/empty.cjs

@@ -8,6 +8,15 @@ var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 
 const eitherOptionalEmptyKind = kind.createEitherKind("optional-empty");
+/**
+ * {@include either/isOptionalEmpty/index.md}
+ */
+/**
+ * {@include either/optionalEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsOptionalEmpty/index.md}
+ */
 function optionalEmpty() {
     return base.eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(create.left("optional", undefined)));
 }

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

@@ -9,6 +9,65 @@ type _EitherOptionalEmpty = (EitherLeft<"optional", undefined> & Kind<typeof eit
 export interface EitherOptionalEmpty extends _EitherOptionalEmpty {
 }
 type Either = EitherRight | EitherLeft;
+/**
+ * Type guard that detects an EitherOptionalEmpty.
+ * 
+ * Signature: `isOptionalEmpty(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const maybeValue = E.optional(true ? "value" : undefined);
+ * 
+ * if (E.isOptionalEmpty(maybeValue)) {
+ * 	// type: E.EitherOptionalEmpty
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/isOptionalEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Builds an EitherLeft<"optional"> containing undefined.
+ * 
+ * Signature: `optionalEmpty()` → returns a value
+ * 
+ * ```ts
+ * const result = E.optionalEmpty();
+ * 
+ * // type: E.EitherOptionalEmpty
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/optionalEmpty
+ * 
+ * @namespace E
+ * 
+ */
+/**
+ * Applies a function only when an optional is empty (undefined).
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenIsOptionalEmpty(input, theFunction)` → returns a value
+ * - Curried: `whenIsOptionalEmpty(theFunction)` → returns a function waiting for the input
+ * 
+ * If the condition matches, the callback runs; otherwise the original value is returned.
+ * 
+ * ```ts
+ * const result = pipe(
+ * 	E.optional(true ? "value" : undefined),
+ * 	E.whenIsOptionalEmpty(() => "empty"),
+ * );
+ * 
+ * // type: E.EitherOptionalFilled<"value"> | "empty"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/either/whenIsOptionalEmpty
+ * 
+ * @namespace E
+ * 
+ */
 export declare function optionalEmpty(): EitherOptionalEmpty;
 export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;

package/dist/either/optional/empty.mjs

@@ -6,6 +6,15 @@ import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 
 const eitherOptionalEmptyKind = createEitherKind("optional-empty");
+/**
+ * {@include either/isOptionalEmpty/index.md}
+ */
+/**
+ * {@include either/optionalEmpty/index.md}
+ */
+/**
+ * {@include either/whenIsOptionalEmpty/index.md}
+ */
 function optionalEmpty() {
     return eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(left("optional", undefined)));
 }

package/dist/either/optional/filled.cjs

@@ -9,6 +9,15 @@ var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
 const eitherOptionalFilledKind = kind.createEitherKind("optional-filled");
+/**
+ * {@include either/isOptionalFilled/index.md}
+ */
+/**
+ * {@include either/optionalFilled/index.md}
+ */
+/**
+ * {@include either/whenIsOptionalFilled/index.md}
+ */
 function optionalFilled(value) {
     return base.eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(create.right("optional", value)));
 }