@duplojs/utils 1.4.44 → 1.4.45

package/dist/either/bool/truthy.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 eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
+const boolTruthyKind = kind.createEitherKind("bool-truthy");
+/**
+ * @deprecated use boolTruthyKind
+ */
+const eitherBoolTruthyKind = boolTruthyKind;
 /**
  * {@include either/boolTruthy/index.md}
  */
@@ -19,12 +23,12 @@ const eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
  * {@include either/whenIsBoolTruthy/index.md}
  */
 function boolTruthy(value) {
-    return base.eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(create.right("bool", value)));
+    return base.boolKind.setTo(boolTruthyKind.setTo(create.right("bool", value)));
 }
 function isBoolTruthy(input) {
     return is.isRight(input)
-        && base.eitherBoolKind.has(input)
-        && eitherBoolTruthyKind.has(input);
+        && base.boolKind.has(input)
+        && boolTruthyKind.has(input);
 }
 function whenIsBoolTruthy(...args) {
     if (args.length === 1) {
@@ -48,6 +52,7 @@ function whenIsBoolTruthy(...args) {
 }
 
 exports.boolTruthy = boolTruthy;
+exports.boolTruthyKind = boolTruthyKind;
 exports.eitherBoolTruthyKind = eitherBoolTruthyKind;
 exports.isBoolTruthy = isBoolTruthy;
 exports.whenIsBoolTruthy = whenIsBoolTruthy;

package/dist/either/bool/truthy.d.ts

@@ -1,15 +1,23 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { eitherBoolKind } from "./base";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { boolKind } from "./base";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { bool } from "./create";
+export declare const boolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-truthy", unknown>>;
+/**
+ * @deprecated use boolTruthyKind
+ */
 export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-truthy", unknown>>;
-type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
-export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extends _EitherBoolTruthy<GenericValue> {
+type _BoolTruthy<GenericValue extends unknown = unknown> = (Right<"bool", GenericValue> & Kind<typeof boolKind.definition> & Kind<typeof boolTruthyKind.definition>);
+export interface BoolTruthy<GenericValue extends unknown = unknown> extends _BoolTruthy<GenericValue> {
 }
 /**
- * Forces the creation of an EitherRight<"bool"> by explicitly marking a truthy value.
+ * @deprecated use BoolTruthy
+ */
+export type EitherBoolTruthy<GenericValue extends unknown = unknown> = BoolTruthy<GenericValue>;
+/**
+ * Forces the creation of an Right<"bool"> by explicitly marking a truthy value.
  * 
  * Signature: `boolTruthy(value)` → returns a value
  * 
@@ -26,7 +34,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 	),
  * );
  * 
- * // type: string | E.EitherBoolTruthy<`${string}@${string}`>
+ * // type: string | E.BoolTruthy<`${string}@${string}`>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/boolTruthy
@@ -45,7 +53,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * const maybeInput = E.bool(true ? true : null);
  * 
  * if (E.isBoolTruthy(maybeInput)) {
- * 	// type: E.EitherBoolTruthy<true>
+ * 	// type: E.BoolTruthy<true>
  * }
  * ```
  * 
@@ -55,7 +63,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 
  */
 /**
- * Callback executed only for EitherBoolTruthy values. Otherwise, the initial value is returned.
+ * Callback executed only for BoolTruthy values. Otherwise, the initial value is returned.
  * 
  * **Supported call styles:**
  * - Classic: `whenIsBoolTruthy(input, theFunction)` → returns a value
@@ -69,7 +77,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 	E.whenIsBoolTruthy(S.toUpperCase),
  * );
  * 
- * // type: E.EitherBoolFalsy<null> | "VALUE"
+ * // type: E.BoolFalsy<null> | "VALUE"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsBoolTruthy
@@ -77,10 +85,10 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * @namespace E
  * 
  */
-export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): EitherBoolTruthy<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
+export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): BoolTruthy<GenericValue>;
+type Either = Right | Left;
+export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, BoolTruthy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, BoolTruthy>;
 export {};

package/dist/either/bool/truthy.mjs

@@ -1,4 +1,4 @@
-import { eitherBoolKind } from './base.mjs';
+import { boolKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { bool } from './create.mjs';
 import { right } from '../right/create.mjs';
@@ -6,7 +6,11 @@ import { isRight } from '../right/is.mjs';
 import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherBoolTruthyKind = createEitherKind("bool-truthy");
+const boolTruthyKind = createEitherKind("bool-truthy");
+/**
+ * @deprecated use boolTruthyKind
+ */
+const eitherBoolTruthyKind = boolTruthyKind;
 /**
  * {@include either/boolTruthy/index.md}
  */
@@ -17,12 +21,12 @@ const eitherBoolTruthyKind = createEitherKind("bool-truthy");
  * {@include either/whenIsBoolTruthy/index.md}
  */
 function boolTruthy(value) {
-    return eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(right("bool", value)));
+    return boolKind.setTo(boolTruthyKind.setTo(right("bool", value)));
 }
 function isBoolTruthy(input) {
     return isRight(input)
-        && eitherBoolKind.has(input)
-        && eitherBoolTruthyKind.has(input);
+        && boolKind.has(input)
+        && boolTruthyKind.has(input);
 }
 function whenIsBoolTruthy(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsBoolTruthy(...args) {
     return either;
 }
 
-export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };
+export { boolTruthy, boolTruthyKind, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };

package/dist/either/future/base.cjs

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

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

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

package/dist/either/future/base.mjs

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

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

@@ -1,12 +1,12 @@
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
-import { type EitherFutureSuccess } from "./success";
-import { type EitherFutureError } from "./error";
+import { type Left } from "../left";
+import { type Right } from "../right";
+import { type FutureSuccess } from "./success";
+import { type FutureError } from "./error";
 import { type IsEqual } from "../../common/types/isEqual";
 import { type AnyValue } from "../../common";
-type Either = EitherRight | EitherLeft;
-type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
-type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? EitherFutureError : never;
+type Either = Right | Left;
+type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? FutureSuccess<Exclude<GenericValue, Either>> : never;
+type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? FutureError : never;
 type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<(Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>), any>;
 export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
     -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
@@ -33,7 +33,7 @@ export declare class Future<const GenericValue extends unknown = unknown> extend
  * );
  * 
  * await maybePromise.then((value) => {
- * 	// type: E.EitherFutureSuccess<number> | E.EitherFutureError
+ * 	// type: E.FutureSuccess<number> | E.FutureError
  * 	return value;
  * });
  * ```

package/dist/either/future/error.cjs

@@ -4,13 +4,18 @@ var base = require('./base.cjs');
 var kind = require('../kind.cjs');
 var create = require('../left/create.cjs');
 
-const eitherFutureErrorKind = kind.createEitherKind("future-error");
+const futureErrorKind = kind.createEitherKind("future-error");
+/**
+ * @deprecated use futureErrorKind
+ */
+const eitherFutureErrorKind = futureErrorKind;
 /**
  * {@include either/futureError/index.md}
  */
 function futureError(value) {
-    return base.eitherFutureKind.setTo(eitherFutureErrorKind.setTo(create.left("future", value)));
+    return base.futureKind.setTo(futureErrorKind.setTo(create.left("future", value)));
 }
 
 exports.eitherFutureErrorKind = eitherFutureErrorKind;
 exports.futureError = futureError;
+exports.futureErrorKind = futureErrorKind;

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

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { eitherFutureKind } from "./base";
+import { type Left } from "../left";
+import { futureKind } from "./base";
+export declare const futureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-error", unknown>>;
+/**
+ * @deprecated use futureErrorKind
+ */
 export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-error", unknown>>;
-type _EitherFutureError = (EitherLeft<"future", unknown> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureErrorKind.definition>);
-export interface EitherFutureError extends _EitherFutureError {
+type _FutureError = (Left<"future", unknown> & Kind<typeof futureKind.definition> & Kind<typeof futureErrorKind.definition>);
+export interface FutureError extends _FutureError {
 }
 /**
- * Creates a Future resolved with an EitherLeft<"future">, ideal for propagating a standardized rejection.
+ * @deprecated use FutureError
+ */
+export type EitherFutureError = FutureError;
+/**
+ * Creates a Future resolved with an Left<"future">, ideal for propagating a standardized rejection.
  * 
  * Signature: `futureError(value)` → returns a value
  * 
@@ -15,7 +23,7 @@ export interface EitherFutureError extends _EitherFutureError {
  * ```ts
  * const future = E.futureError("error");
  * 
- * // type: E.EitherFutureError
+ * // type: E.FutureError
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/futureError
@@ -23,5 +31,5 @@ export interface EitherFutureError extends _EitherFutureError {
  * @namespace E
  * 
  */
-export declare function futureError(value: unknown): EitherFutureError;
+export declare function futureError(value: unknown): FutureError;
 export {};

package/dist/either/future/error.mjs

@@ -1,13 +1,17 @@
-import { eitherFutureKind } from './base.mjs';
+import { futureKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { left } from '../left/create.mjs';
 
-const eitherFutureErrorKind = createEitherKind("future-error");
+const futureErrorKind = createEitherKind("future-error");
+/**
+ * @deprecated use futureErrorKind
+ */
+const eitherFutureErrorKind = futureErrorKind;
 /**
  * {@include either/futureError/index.md}
  */
 function futureError(value) {
-    return eitherFutureKind.setTo(eitherFutureErrorKind.setTo(left("future", value)));
+    return futureKind.setTo(futureErrorKind.setTo(left("future", value)));
 }
 
-export { eitherFutureErrorKind, futureError };
+export { eitherFutureErrorKind, futureError, futureErrorKind };

package/dist/either/future/success.cjs

@@ -4,13 +4,18 @@ var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 var create = require('../right/create.cjs');
 
-const eitherFutureSuccessKind = kind.createEitherKind("future-success");
+const futureSuccessKind = kind.createEitherKind("future-success");
+/**
+ * @deprecated use futureSuccessKind
+ */
+const eitherFutureSuccessKind = futureSuccessKind;
 /**
  * {@include either/futureSuccess/index.md}
  */
 function futureSuccess(value) {
-    return base.eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(create.right("future", value)));
+    return base.futureKind.setTo(futureSuccessKind.setTo(create.right("future", value)));
 }
 
 exports.eitherFutureSuccessKind = eitherFutureSuccessKind;
 exports.futureSuccess = futureSuccess;
+exports.futureSuccessKind = futureSuccessKind;

package/dist/either/future/success.d.ts

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
-import { eitherFutureKind } from "./base";
-import { type EitherRight } from "../right";
+import { futureKind } from "./base";
+import { type Right } from "../right";
+export declare const futureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-success", unknown>>;
+/**
+ * @deprecated use futureSuccessKind
+ */
 export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-success", unknown>>;
-type _EitherFutureSuccess<GenericValue extends unknown = unknown> = (EitherRight<"future", GenericValue> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureSuccessKind.definition>);
-export interface EitherFutureSuccess<GenericValue extends unknown = unknown> extends _EitherFutureSuccess<GenericValue> {
+type _FutureSuccess<GenericValue extends unknown = unknown> = (Right<"future", GenericValue> & Kind<typeof futureKind.definition> & Kind<typeof futureSuccessKind.definition>);
+export interface FutureSuccess<GenericValue extends unknown = unknown> extends _FutureSuccess<GenericValue> {
 }
 /**
- * Creates a Future resolved with an EitherRight<"future">.
+ * @deprecated use FutureSuccess
+ */
+export type EitherFutureSuccess<GenericValue extends unknown = unknown> = FutureSuccess<GenericValue>;
+/**
+ * Creates a Future resolved with an Right<"future">.
  * 
  * Signature: `futureSuccess(value)` → returns a value
  * 
@@ -15,7 +23,7 @@ export interface EitherFutureSuccess<GenericValue extends unknown = unknown> ext
  * ```ts
  * const future = E.futureSuccess("value");
  * 
- * // type: E.EitherFutureSuccess<"value">
+ * // type: E.FutureSuccess<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/futureSuccess
@@ -23,5 +31,5 @@ export interface EitherFutureSuccess<GenericValue extends unknown = unknown> ext
  * @namespace E
  * 
  */
-export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): EitherFutureSuccess<GenericValue>;
+export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): FutureSuccess<GenericValue>;
 export {};

package/dist/either/future/success.mjs

@@ -1,13 +1,17 @@
 import { createEitherKind } from '../kind.mjs';
-import { eitherFutureKind } from './base.mjs';
+import { futureKind } from './base.mjs';
 import { right } from '../right/create.mjs';
 
-const eitherFutureSuccessKind = createEitherKind("future-success");
+const futureSuccessKind = createEitherKind("future-success");
+/**
+ * @deprecated use futureSuccessKind
+ */
+const eitherFutureSuccessKind = futureSuccessKind;
 /**
  * {@include either/futureSuccess/index.md}
  */
 function futureSuccess(value) {
-    return eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(right("future", value)));
+    return futureKind.setTo(futureSuccessKind.setTo(right("future", value)));
 }
 
-export { eitherFutureSuccessKind, futureSuccess };
+export { eitherFutureSuccessKind, futureSuccess, futureSuccessKind };

package/dist/either/hasInformation.cjs

@@ -8,8 +8,8 @@ function hasInformation(...args) {
         return (input) => hasInformation(input, information);
     }
     const [input, information] = args;
-    return kind.eitherInformationKind.has(input)
-        && kind.eitherInformationKind.getValue(input) === information;
+    return kind.informationKind.has(input)
+        && kind.informationKind.getValue(input) === information;
 }
 
 exports.hasInformation = hasInformation;

package/dist/either/hasInformation.d.ts

@@ -1,8 +1,8 @@
 import { type Kind } from "../common";
-import { type EitherLeft } from "./left";
-import { type EitherRight } from "./right";
-import { eitherInformationKind } from "./kind";
-type Either = EitherRight | EitherLeft;
+import { type Left } from "./left";
+import { type Right } from "./right";
+import { informationKind } from "./kind";
+type Either = Right | Left;
 /**
  * Type guard based on the literal information stored in the Either. Lets you precisely target a business case without extra introspection.
  * 
@@ -20,10 +20,10 @@ type Either = EitherRight | EitherLeft;
  * 	: E.left("left-3", 3);
  * 
  * if (E.isLeft(result)) {
- * 	// type: E.EitherLeft<"left-2", 2> | E.EitherLeft<"left-3", 3>
+ * 	// type: E.Left<"left-2", 2> | E.Left<"left-3", 3>
  * 
  * 	if (E.hasInformation(result, "left-2")) {
- * 		// type: E.EitherLeft<"left-2", 2>
+ * 		// type: E.Left<"left-2", 2>
  * 	}
  * }
  * ```
@@ -33,6 +33,6 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(information: GenericInformation): (input: GenericInput) => input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
-export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never)>(information: GenericInformation): (input: GenericInput) => input is Extract<GenericInput, Kind<typeof informationKind.definition, GenericInformation>>;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof informationKind.definition, GenericInformation>>;
 export {};

package/dist/either/hasInformation.mjs

@@ -1,4 +1,4 @@
-import { eitherInformationKind } from './kind.mjs';
+import { informationKind } from './kind.mjs';
 
 function hasInformation(...args) {
     if (args.length === 1) {
@@ -6,8 +6,8 @@ function hasInformation(...args) {
         return (input) => hasInformation(input, information);
     }
     const [input, information] = args;
-    return eitherInformationKind.has(input)
-        && eitherInformationKind.getValue(input) === information;
+    return informationKind.has(input)
+        && informationKind.getValue(input) === information;
 }
 
 export { hasInformation };

package/dist/either/index.cjs

@@ -47,75 +47,99 @@ exports.hasInformation = hasInformation.hasInformation;
 exports.whenHasInformation = whenHasInformation.whenHasInformation;
 exports.createEitherKind = kind.createEitherKind;
 exports.eitherInformationKind = kind.eitherInformationKind;
+exports.informationKind = kind.informationKind;
 exports.callbackError = safeCallback.callbackError;
+exports.callbackErrorKind = safeCallback.callbackErrorKind;
 exports.callbackSuccess = safeCallback.callbackSuccess;
+exports.callbackSuccessKind = safeCallback.callbackSuccessKind;
 exports.eitherCallbackErrorKind = safeCallback.eitherCallbackErrorKind;
 exports.eitherCallbackSuccessKind = safeCallback.eitherCallbackSuccessKind;
 exports.safeCallback = safeCallback.safeCallback;
 exports.bool = create.bool;
 exports.boolFalsy = falsy.boolFalsy;
+exports.boolFalsyKind = falsy.boolFalsyKind;
 exports.eitherBoolFalsyKind = falsy.eitherBoolFalsyKind;
 exports.isBoolFalsy = falsy.isBoolFalsy;
 exports.whenIsBoolFalsy = falsy.whenIsBoolFalsy;
 exports.boolTruthy = truthy.boolTruthy;
+exports.boolTruthyKind = truthy.boolTruthyKind;
 exports.eitherBoolTruthyKind = truthy.eitherBoolTruthyKind;
 exports.isBoolTruthy = truthy.isBoolTruthy;
 exports.whenIsBoolTruthy = truthy.whenIsBoolTruthy;
+exports.boolKind = base.boolKind;
 exports.eitherBoolKind = base.eitherBoolKind;
 exports.Future = create$1.Future;
 exports.future = create$1.future;
 exports.eitherFutureErrorKind = error.eitherFutureErrorKind;
 exports.futureError = error.futureError;
+exports.futureErrorKind = error.futureErrorKind;
 exports.eitherFutureSuccessKind = success.eitherFutureSuccessKind;
 exports.futureSuccess = success.futureSuccess;
+exports.futureSuccessKind = success.futureSuccessKind;
 exports.eitherFutureKind = base$1.eitherFutureKind;
+exports.futureKind = base$1.futureKind;
 exports.eitherLeftKind = create$2.eitherLeftKind;
 exports.left = create$2.left;
+exports.leftKind = create$2.leftKind;
 exports.eitherErrorKind = error$1.eitherErrorKind;
 exports.error = error$1.error;
+exports.errorKind = error$1.errorKind;
 exports.eitherFailKind = fail.eitherFailKind;
 exports.fail = fail.fail;
+exports.failKind = fail.failKind;
 exports.isLeft = is.isLeft;
 exports.whenIsLeft = when.whenIsLeft;
 exports.nullable = create$3.nullable;
 exports.eitherNullableEmptyKind = empty.eitherNullableEmptyKind;
 exports.isNullableEmpty = empty.isNullableEmpty;
 exports.nullableEmpty = empty.nullableEmpty;
+exports.nullableEmptyKind = empty.nullableEmptyKind;
 exports.whenIsNullableEmpty = empty.whenIsNullableEmpty;
 exports.eitherNullableFilledKind = filled.eitherNullableFilledKind;
 exports.isNullableFilled = filled.isNullableFilled;
 exports.nullableFilled = filled.nullableFilled;
+exports.nullableFilledKind = filled.nullableFilledKind;
 exports.whenIsNullableFilled = filled.whenIsNullableFilled;
 exports.eitherNullableKind = base$2.eitherNullableKind;
+exports.nullableKind = base$2.nullableKind;
 exports.nullish = create$4.nullish;
 exports.eitherNullishEmptyKind = empty$1.eitherNullishEmptyKind;
 exports.isNullishEmpty = empty$1.isNullishEmpty;
 exports.nullishEmpty = empty$1.nullishEmpty;
+exports.nullishEmptyKind = empty$1.nullishEmptyKind;
 exports.whenIsNullishEmpty = empty$1.whenIsNullishEmpty;
 exports.eitherNullishFilledKind = filled$1.eitherNullishFilledKind;
 exports.isNullishFilled = filled$1.isNullishFilled;
 exports.nullishFilled = filled$1.nullishFilled;
+exports.nullishFilledKind = filled$1.nullishFilledKind;
 exports.whenIsNullishFilled = filled$1.whenIsNullishFilled;
 exports.eitherNullishKind = base$3.eitherNullishKind;
+exports.nullishKind = base$3.nullishKind;
 exports.optional = create$5.optional;
 exports.eitherOptionalEmptyKind = empty$2.eitherOptionalEmptyKind;
 exports.isOptionalEmpty = empty$2.isOptionalEmpty;
 exports.optionalEmpty = empty$2.optionalEmpty;
+exports.optionalEmptyKind = empty$2.optionalEmptyKind;
 exports.whenIsOptionalEmpty = empty$2.whenIsOptionalEmpty;
 exports.eitherOptionalFilledKind = filled$2.eitherOptionalFilledKind;
 exports.isOptionalFilled = filled$2.isOptionalFilled;
 exports.optionalFilled = filled$2.optionalFilled;
+exports.optionalFilledKind = filled$2.optionalFilledKind;
 exports.whenIsOptionalFilled = filled$2.whenIsOptionalFilled;
 exports.eitherOptionalKind = base$4.eitherOptionalKind;
+exports.optionalKind = base$4.optionalKind;
 exports.rightAsyncPipe = asyncPipe.rightAsyncPipe;
 exports.eitherRightKind = create$6.eitherRightKind;
 exports.right = create$6.right;
+exports.rightKind = create$6.rightKind;
 exports.isRight = is$1.isRight;
 exports.eitherOkKind = ok.eitherOkKind;
 exports.ok = ok.ok;
+exports.okKind = ok.okKind;
 exports.rightPipe = pipe.rightPipe;
 exports.eitherSuccessKind = success$1.eitherSuccessKind;
 exports.success = success$1.success;
+exports.successKind = success$1.successKind;
 exports.whenIsRight = when$1.whenIsRight;
 exports.group = group.group;
 exports.asyncGroup = asyncGroup.asyncGroup;

package/dist/either/index.mjs

@@ -1,38 +1,38 @@
 export { hasInformation } from './hasInformation.mjs';
 export { whenHasInformation } from './whenHasInformation.mjs';
-export { createEitherKind, eitherInformationKind } from './kind.mjs';
-export { callbackError, callbackSuccess, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback } from './safeCallback.mjs';
+export { createEitherKind, eitherInformationKind, informationKind } from './kind.mjs';
+export { callbackError, callbackErrorKind, callbackSuccess, callbackSuccessKind, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback } from './safeCallback.mjs';
 export { bool } from './bool/create.mjs';
-export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
-export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';
-export { eitherBoolKind } from './bool/base.mjs';
+export { boolFalsy, boolFalsyKind, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
+export { boolTruthy, boolTruthyKind, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';
+export { boolKind, eitherBoolKind } from './bool/base.mjs';
 export { Future, future } from './future/create.mjs';
-export { eitherFutureErrorKind, futureError } from './future/error.mjs';
-export { eitherFutureSuccessKind, futureSuccess } from './future/success.mjs';
-export { eitherFutureKind } from './future/base.mjs';
-export { eitherLeftKind, left } from './left/create.mjs';
-export { eitherErrorKind, error } from './left/error.mjs';
-export { eitherFailKind, fail } from './left/fail.mjs';
+export { eitherFutureErrorKind, futureError, futureErrorKind } from './future/error.mjs';
+export { eitherFutureSuccessKind, futureSuccess, futureSuccessKind } from './future/success.mjs';
+export { eitherFutureKind, futureKind } from './future/base.mjs';
+export { eitherLeftKind, left, leftKind } from './left/create.mjs';
+export { eitherErrorKind, error, errorKind } from './left/error.mjs';
+export { eitherFailKind, fail, failKind } from './left/fail.mjs';
 export { isLeft } from './left/is.mjs';
 export { whenIsLeft } from './left/when.mjs';
 export { nullable } from './nullable/create.mjs';
-export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty } from './nullable/empty.mjs';
-export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled } from './nullable/filled.mjs';
-export { eitherNullableKind } from './nullable/base.mjs';
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, nullableEmptyKind, whenIsNullableEmpty } from './nullable/empty.mjs';
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, nullableFilledKind, whenIsNullableFilled } from './nullable/filled.mjs';
+export { eitherNullableKind, nullableKind } from './nullable/base.mjs';
 export { nullish } from './nullish/create.mjs';
-export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty } from './nullish/empty.mjs';
-export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled } from './nullish/filled.mjs';
-export { eitherNullishKind } from './nullish/base.mjs';
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, nullishEmptyKind, whenIsNullishEmpty } from './nullish/empty.mjs';
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, nullishFilledKind, whenIsNullishFilled } from './nullish/filled.mjs';
+export { eitherNullishKind, nullishKind } from './nullish/base.mjs';
 export { optional } from './optional/create.mjs';
-export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty } from './optional/empty.mjs';
-export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled } from './optional/filled.mjs';
-export { eitherOptionalKind } from './optional/base.mjs';
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, optionalEmptyKind, whenIsOptionalEmpty } from './optional/empty.mjs';
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, optionalFilledKind, whenIsOptionalFilled } from './optional/filled.mjs';
+export { eitherOptionalKind, optionalKind } from './optional/base.mjs';
 export { rightAsyncPipe } from './right/asyncPipe.mjs';
-export { eitherRightKind, right } from './right/create.mjs';
+export { eitherRightKind, right, rightKind } from './right/create.mjs';
 export { isRight } from './right/is.mjs';
-export { eitherOkKind, ok } from './right/ok.mjs';
+export { eitherOkKind, ok, okKind } from './right/ok.mjs';
 export { rightPipe } from './right/pipe.mjs';
-export { eitherSuccessKind, success } from './right/success.mjs';
+export { eitherSuccessKind, success, successKind } from './right/success.mjs';
 export { whenIsRight } from './right/when.mjs';
 export { group } from './right/group.mjs';
 export { asyncGroup } from './right/asyncGroup.mjs';