@duplojs/utils 1.4.32 → 1.4.33

package/dist/common/override.mjs

@@ -2,6 +2,9 @@ import { createGlobalStore } from './globalStore.mjs';
 
 const SymbolOverrideStore = Symbol.for("@duplojs/utils/override");
 const overrideStore = createGlobalStore(SymbolOverrideStore, {});
+/**
+ * {@include common/override/index.md}
+ */
 function createOverride(overrideName) {
     const overridePropertiesStore = overrideStore.value[overrideName] ?? {};
     overrideStore.value[overrideName] ||= overridePropertiesStore;

package/dist/common/pipe.d.ts

@@ -1,5 +1,34 @@
 import { type BreakGenericLink, type EscapeVoid } from "./types";
 import { type AnyValue } from "./types/anyValue";
+/**
+ * The pipe() method chains up to 15 synchronous functions, passing the output of one as the input of the next. It returns the last computed value and stays fully typed at each step.
+ * 
+ * Signature: `pipe(input, pipe1, pipe2)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = {
+ * 	price: 10,
+ * 	quantity: 3,
+ * };
+ * const tvaRate = 1.2;
+ * const digit = 2;
+ * 
+ * const result = pipe(
+ * 	input,
+ * 	({ price, quantity }) => price * quantity,
+ * 	(value) => value * tvaRate,
+ * 	(value) => `${value.toFixed(digit)}€`,
+ * );
+ * // result: "36€"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/pipe
+ * 
+ * @namespace C
+ * 
+ */
 export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: GenericInput) => GenericOutputPipe1): BreakGenericLink<GenericOutputPipe1>;
 export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2): BreakGenericLink<GenericOutputPipe2>;
 export declare function pipe<GenericInput extends AnyValue, GenericOutputPipe1 extends AnyValue | EscapeVoid, GenericOutputPipe2 extends AnyValue | EscapeVoid, GenericOutputPipe3 extends AnyValue | EscapeVoid>(input: GenericInput, pipe1: (input: GenericInput) => GenericOutputPipe1, pipe2: (input: GenericOutputPipe1) => GenericOutputPipe2, pipe3: (input: GenericOutputPipe2) => GenericOutputPipe3): BreakGenericLink<GenericOutputPipe3>;

package/dist/common/promiseObject.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/promiseObject/index.md}
+ */
 function promiseObject(object) {
     return Promise
         .all(Object.entries(object)

package/dist/common/promiseObject.d.ts

@@ -4,4 +4,30 @@ import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
 export type AwaitedPromiseObject<GenericObject extends Record<string, MaybePromise<unknown>>> = {
     [Prop in keyof GenericObject]: Awaited<GenericObject[Prop]>;
 };
+/**
+ * The promiseObject() function transforms an object of promises (or values) into a promise of a resolved object, keeping keys and precise typing.
+ * 
+ * Signature: `promiseObject(promises)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = {
+ * 	user: Promise.resolve({
+ * 		id: 1,
+ * 		name: "Alice",
+ * 	}),
+ * 	count: 3,
+ * };
+ * 
+ * const result = await promiseObject(input);
+ * 
+ * // type: { user: { id: number; name: string; }; count: number; }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/promiseObject
+ * 
+ * @namespace C
+ * 
+ */
 export declare function promiseObject<GenericValue extends AnyValue, GenericObject extends Record<string, MaybePromise<GenericValue>>>(object: GenericObject): Promise<SimplifyTopLevel<AwaitedPromiseObject<GenericObject>>>;

package/dist/common/promiseObject.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/promiseObject/index.md}
+ */
 function promiseObject(object) {
     return Promise
         .all(Object.entries(object)

package/dist/common/simpleClone.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/simpleClone/index.md}
+ */
 function simpleClone(unknownValue) {
     if (!unknownValue) {
         return unknownValue;

package/dist/common/simpleClone.d.ts

@@ -1 +1,24 @@
+/**
+ * The simpleClone() function quickly duplicates a value without advanced logic, useful for shallow copies or simple structures.
+ * 
+ * Signature: `simpleClone(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const original = [
+ * 	1,
+ * 	2,
+ * 	3,
+ * ];
+ * const copy = simpleClone(original);
+ * 
+ * // type: number[]
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/simpleClone
+ * 
+ * @namespace C
+ * 
+ */
 export declare function simpleClone<GenericObject extends unknown = unknown>(unknownValue: GenericObject): GenericObject;

package/dist/common/simpleClone.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/simpleClone/index.md}
+ */
 function simpleClone(unknownValue) {
     if (!unknownValue) {
         return unknownValue;

package/dist/common/sleep.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/sleep/index.md}
+ */
 function sleep(millieSeconde) {
     return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
 }

package/dist/common/sleep.d.ts

@@ -1 +1,22 @@
+/**
+ * The sleep() function creates an asynchronous pause for a number of milliseconds.
+ * 
+ * Signature: `sleep(duration)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const start = Date.now();
+ * 
+ * await sleep(5);
+ * 
+ * const elapsed = Date.now() - start;
+ * // elapsed >= 5 (approx)
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/sleep
+ * 
+ * @namespace C
+ * 
+ */
 export declare function sleep(millieSeconde?: number): Promise<void>;

package/dist/common/sleep.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/sleep/index.md}
+ */
 function sleep(millieSeconde) {
     return new Promise((resolve) => void setTimeout(resolve, millieSeconde));
 }

package/dist/common/stringToBytes.cjs

@@ -21,6 +21,9 @@ const unitMapper = {
     tb: Math.pow(1024, 4),
     pb: Math.pow(1024, 5),
 };
+/**
+ * {@include common/stringToBytes/index.md}
+ */
 function stringToBytes(bytesInString) {
     if (typeof bytesInString === "number") {
         return bytesInString;

package/dist/common/stringToBytes.d.ts

@@ -14,5 +14,22 @@ declare const unitMapper: {
     pb: number;
 };
 export type BytesInString = `${number}${keyof typeof unitMapper}`;
+/**
+ * The stringToBytes() function converts a size ("10mb", "2gb", etc.) or a number into bytes. It throws a typed error if the format is invalid.
+ * 
+ * Signature: `stringToBytes(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const size = stringToBytes("1.5gb");
+ * // size: number of bytes for 1.5 gigabytes
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/stringToBytes
+ * 
+ * @namespace C
+ * 
+ */
 export declare function stringToBytes(bytesInString: BytesInString | number): number;
 export {};

package/dist/common/stringToBytes.mjs

@@ -19,6 +19,9 @@ const unitMapper = {
     tb: Math.pow(1024, 4),
     pb: Math.pow(1024, 5),
 };
+/**
+ * {@include common/stringToBytes/index.md}
+ */
 function stringToBytes(bytesInString) {
     if (typeof bytesInString === "number") {
         return bytesInString;

package/dist/common/stringToMillisecond.cjs

@@ -21,6 +21,9 @@ const unitMapper = {
     w: 604_800_000,
 };
 const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>ms|s|m|h|d|w)/;
+/**
+ * {@include common/stringToMillisecond/index.md}
+ */
 function stringToMillisecond(millisecondInString, ...millisecondInStrings) {
     if (typeof millisecondInString === "number") {
         return millisecondInString;

package/dist/common/stringToMillisecond.d.ts

@@ -14,5 +14,22 @@ declare const unitMapper: {
     w: number;
 };
 export type MillisecondInString = `${number}${keyof typeof unitMapper}` | `${number}.${number}${keyof typeof unitMapper}`;
+/**
+ * The stringToMillisecond() function converts durations expressed as a string ("10s", "2h", "1.5d", etc.) or a number into milliseconds. It throws a typed error if the format is invalid.
+ * 
+ * Signature: `stringToMillisecond(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const duration = stringToMillisecond("1.5d", "2h", 5000);
+ * // duration: number of milliseconds for 1.5 days + 2 hours + 5 seconds
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/stringToMillisecond
+ * 
+ * @namespace C
+ * 
+ */
 export declare function stringToMillisecond(millisecondInString: MillisecondInString | number, ...millisecondInStrings: (MillisecondInString | number)[]): number;
 export {};

package/dist/common/stringToMillisecond.mjs

@@ -19,6 +19,9 @@ const unitMapper = {
     w: 604_800_000,
 };
 const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>ms|s|m|h|d|w)/;
+/**
+ * {@include common/stringToMillisecond/index.md}
+ */
 function stringToMillisecond(millisecondInString, ...millisecondInStrings) {
     if (typeof millisecondInString === "number") {
         return millisecondInString;

package/dist/common/toJSON.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/toJSON/index.md}
+ */
 function toJSON(value) {
     if (typeof value === "string"
         || typeof value === "number"

package/dist/common/toJSON.d.ts

@@ -8,4 +8,39 @@ export type ToJSON<GenericValue extends unknown> = GenericValue extends number |
 ] : GenericValue extends any[] ? ToJSON<GenericValue[number]>[] : GenericValue extends object ? {
     [Prop in keyof GenericValue as GenericValue[Prop] extends AnyFunction ? never : Prop]: ToJSON<GenericValue[Prop]>;
 } : undefined;
+/**
+ * The toJSON() function prepares a value for JSON serialization while respecting objects' toJSON methods, traversing arrays/tuples, and excluding functions.
+ * 
+ * Signature: `toJSON(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = toJSON({
+ * 	prop: 1,
+ * 	prop1: "test",
+ * 	prop2: new Date("2025-08-19T15:14:19.467Z"),
+ * 	prop3: null,
+ * 	prop4: undefined,
+ * 	prop5: {
+ * 		subProp: [{ prop1: 1 }],
+ * 		subProp1: {
+ * 			toJSON() {
+ * 				return "test";
+ * 			},
+ * 		},
+ * 	},
+ * 	method() {
+ * 		return void 0;
+ * 	},
+ * });
+ * 
+ * // type: { prop: number; prop1: string; prop2: string; prop3: null; prop4: undefined; prop5: { subProp: { prop1: number; }[]; subProp1: "test"; }; }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toJSON
+ * 
+ * @namespace C
+ * 
+ */
 export declare function toJSON<GenericValue extends unknown>(value: GenericValue): ToJSON<GenericValue>;

package/dist/common/toJSON.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/toJSON/index.md}
+ */
 function toJSON(value) {
     if (typeof value === "string"
         || typeof value === "number"

package/dist/common/toString.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/toString/index.md}
+ */
 function toString(value) {
     return `${value}`;
 }

package/dist/common/toString.d.ts

@@ -1 +1,19 @@
+/**
+ * The toString() function converts a literal (number, string, bigint, boolean, null, undefined) into a typed template string.
+ * 
+ * Signature: `toString(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = toString(42n);
+ * 
+ * // type: "42"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toString
+ * 
+ * @namespace C
+ * 
+ */
 export declare function toString<GenericValue extends number | string | bigint | boolean | null | undefined>(value: GenericValue): `${GenericValue}`;

package/dist/common/toString.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/toString/index.md}
+ */
 function toString(value) {
     return `${value}`;
 }

package/dist/common/toTransform.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/toTransform/index.md}
+ */
 function toTransform(value) {
     if (typeof value === "string"
         || typeof value === "number"

package/dist/common/toTransform.d.ts

@@ -8,4 +8,45 @@ export type ToTransform<GenericValue extends unknown> = GenericValue extends num
 ] : GenericValue extends any[] ? ToTransform<GenericValue[number]>[] : GenericValue extends Record<number, unknown> ? {
     [Prop in keyof GenericValue]: ToTransform<GenericValue[Prop]>;
 } : GenericValue;
+/**
+ * The toTransform() function recursively applies objects' toTransform methods and traverses arrays/tuples to produce a value ready to be transported (DTO).
+ * 
+ * Signature: `toTransform(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * class Money {
+ * 	public constructor(
+ * 		public amount: number,
+ * 		public currency: string,
+ * 	) {}
+ * 
+ * 	public toTransform() {
+ * 		return {
+ * 			amount: this.amount,
+ * 			currency: this.currency,
+ * 		};
+ * 	}
+ * }
+ * 
+ * const input = {
+ * 	id: "INV-1",
+ * 	total: new Money(99, "EUR"),
+ * 	lines: [
+ * 		new Money(49.5, "EUR"),
+ * 		new Money(49.5, "EUR"),
+ * 	],
+ * };
+ * 
+ * const result = toTransform(input);
+ * 
+ * // type: { id: string; total: { amount: number; currency: string; }; lines: { amount: number; currency: string; }[]; }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toTransform
+ * 
+ * @namespace C
+ * 
+ */
 export declare function toTransform<GenericValue extends unknown>(value: GenericValue): ToTransform<GenericValue>;

package/dist/common/toTransform.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/toTransform/index.md}
+ */
 function toTransform(value) {
     if (typeof value === "string"
         || typeof value === "number"

package/dist/common/toWrappedValue.cjs

@@ -2,6 +2,9 @@
 
 var wrapValue = require('./wrapValue.cjs');
 
+/**
+ * {@include common/toWrappedValue/index.md}
+ */
 function toWrappedValue(value) {
     return wrapValue.isWrappedValue(value)
         ? value

package/dist/common/toWrappedValue.d.ts

@@ -2,4 +2,26 @@ import { type WrappedValue } from "../common/wrapValue";
 import { type MaybeWrapped } from "./types/maybeWrapped";
 import { type AnyValue } from "./types";
 export type ToWrappedValue<GenericValue extends unknown> = GenericValue extends WrappedValue ? GenericValue : WrappedValue<GenericValue>;
+/**
+ * The toWrappedValue() function ensures a value is wrapped: if it is already a WrappedValue, it is returned as is, otherwise it is wrapped.
+ * 
+ * Signature: `toWrappedValue(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const already = toWrappedValue({ id: 1 });
+ * 
+ * // type: WrappedValue<{ id: number }>
+ * 
+ * const again = toWrappedValue(already);
+ * 
+ * // type: WrappedValue<{ id: number }>
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toWrappedValue
+ * 
+ * @namespace C
+ * 
+ */
 export declare function toWrappedValue<GenericInnerValue extends AnyValue, GenericValue extends MaybeWrapped<GenericInnerValue>>(value: GenericValue): ToWrappedValue<GenericValue>;

package/dist/common/toWrappedValue.mjs

@@ -1,5 +1,8 @@
 import { wrapValue, isWrappedValue } from './wrapValue.mjs';
 
+/**
+ * {@include common/toWrappedValue/index.md}
+ */
 function toWrappedValue(value) {
     return isWrappedValue(value)
         ? value

package/dist/common/truthy.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include common/truthy/index.md}
+ */
 function truthy(input) {
     return !!input;
 }

package/dist/common/truthy.d.ts

@@ -1,3 +1,30 @@
 import { type FalsyValue } from "./types";
 export type TruthyValue<GenericInput extends unknown> = Exclude<GenericInput, FalsyValue>;
+/**
+ * The truthy() function is a type guard that keeps only truthy values (false, 0, "", null, undefined are excluded).
+ * 
+ * Signature: `truthy(input)` → returns a value
+ * 
+ * Acts as a type guard and narrows the input type when true.
+ * 
+ * ```ts
+ * const values = [
+ * 	0,
+ * 	1,
+ * 	2,
+ * 	"",
+ * 	"toto",
+ * 	null,
+ * ] as const;
+ * 
+ * const result = A.filter(values, truthy);
+ * 
+ * // type: (1 | 2 | "toto")[]
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/truthy
+ * 
+ * @namespace C
+ * 
+ */
 export declare function truthy<GenericInput extends unknown>(input: GenericInput): input is TruthyValue<GenericInput>;

package/dist/common/truthy.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include common/truthy/index.md}
+ */
 function truthy(input) {
     return !!input;
 }

package/dist/common/unwrap.d.ts

@@ -1,3 +1,25 @@
 import { type WrappedValue } from "./wrapValue";
 export type Unwrap<GenericAnyValue extends unknown> = GenericAnyValue extends WrappedValue<infer inferredValue> ? inferredValue : GenericAnyValue;
+/**
+ * The unwrap() function extracts the inner value of a WrappedValue. If the input is not wrapped, it is returned as is.
+ * 
+ * Signature: `unwrap(value)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const wrapped = wrapValue("value");
+ * 
+ * // type: WrappedValue<"value">
+ * 
+ * const value = unwrap(wrapped);
+ * 
+ * // type: "value"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/unwrap
+ * 
+ * @namespace C
+ * 
+ */
 export declare function unwrap<const GenericValue extends unknown>(anyValue: GenericValue): Unwrap<GenericValue>;

package/dist/common/when.d.ts

@@ -1,4 +1,44 @@
 import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+/**
+ * The when() function applies a transformation if a predicate is true (or if a type guard succeeds). Otherwise, the input value is returned as is. Exists in immediate or curried form.
+ * 
+ * **Supported call styles:**
+ * - Classic: `when(input, predicate, theFunction)` → returns a value
+ * - Curried: `when(predicate, theFunction)` → returns a function waiting for the input
+ * - Classic predicate: `when(input, predicate, theFunction)` → narrows the input type
+ * - Curried predicate: `when(predicate, theFunction)` → narrows the input type
+ * 
+ * Predicate overloads (type guards) narrow the output type.
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * type Input = "success" | "error";
+ * 
+ * const input = "success" as Input;
+ * 
+ * const direct = when(
+ * 	input,
+ * 	equal("success"),
+ * 	() => "ok",
+ * );
+ * // result: "ok"
+ * 
+ * const piped = pipe(
+ * 	input,
+ * 	when(
+ * 		equal("success"),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/when
+ * 
+ * @namespace C
+ * 
+ */
 export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): GenericOutput | Exclude<GenericInput, GenericPredicatedInput>;
 export declare function when<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;

package/dist/common/whenElse.d.ts

@@ -1,4 +1,46 @@
 import { type EscapeVoid, type AnyValue, type BreakGenericLink } from "./types";
+/**
+ * The whenElse() function offers two explicit branches: if the predicate is true, theFunction runs, otherwise elseFunction. Return types stay disjoint and preserved.
+ * 
+ * **Supported call styles:**
+ * - Classic: `whenElse(input, predicate, theFunction, elseFunction)` → returns a value
+ * - Curried: `whenElse(predicate, theFunction, elseFunction)` → returns a function waiting for the input
+ * - Classic predicate: `whenElse(input, predicate, theFunction, elseFunction)` → narrows the input type
+ * - Curried predicate: `whenElse(predicate, theFunction, elseFunction)` → narrows the input type
+ * 
+ * Predicate overloads (type guards) narrow the output type.
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * type Input = "success" | "error";
+ * 
+ * const input = "success" as Input;
+ * 
+ * const direct = whenElse(
+ * 	input,
+ * 	equal("success"),
+ * 	() => "ok",
+ * 	() => "fail",
+ * );
+ * // result: "ok"
+ * 
+ * const piped = pipe(
+ * 	input,
+ * 	whenElse(
+ * 		equal("success"),
+ * 		() => "ok",
+ * 		() => "fail",
+ * 	),
+ * );
+ * // result: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/whenElse
+ * 
+ * @namespace C
+ * 
+ */
 export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): (input: GenericInput) => BreakGenericLink<GenericOutput1> | BreakGenericLink<GenericOutput2>;
 export declare function whenElse<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput1, elseFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput2): GenericOutput1 | GenericOutput2;
 export declare function whenElse<GenericInput extends AnyValue, GenericOutput1 extends AnyValue | EscapeVoid, GenericOutput2 extends AnyValue | EscapeVoid>(predicate: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput1, elseFunction: (predicatedInput: GenericInput) => GenericOutput2): (input: GenericInput) => GenericOutput1 | GenericOutput2;