diff --git a/.commands/test-lint.sh b/.commands/test-lint.sh
new file mode 100755
index 000000000..45a248e5d
--- /dev/null
+++ b/.commands/test-lint.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+ARGUMENTS="$@"
+
+# scripts
+eslint --quiet $ARGUMENTS scripts/
+# tests
+eslint --quiet $ARGUMENTS tests/
+eslint --quiet $ARGUMENTS integration/
+# documentation
+eslint --quiet $ARGUMENTS docs/
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 523b7c14c..70a596b8b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
node_modules
dist
coverage
-cache
\ No newline at end of file
+cache
+.temp
\ No newline at end of file
diff --git a/docs/en/v1/api/clean/index.md b/docs/en/v1/api/clean/index.md
index d5867a461..9c6120a7d 100644
--- a/docs/en/v1/api/clean/index.md
+++ b/docs/en/v1/api/clean/index.md
@@ -69,6 +69,12 @@ Declares an aggregate of linked business actions that must run in order.
### [equal](/en/v1/api/clean/primitives/operators/equal)
Compares two wrapped primitives (or a primitive and a raw value) with a type guard.
+### [matchWithString](/en/v1/api/clean/primitives/operators/matchWithString)
+Performs exhaustive matching with raw string keys and passes the narrowed original Clean primitive.
+
+### [matchWithNumber](/en/v1/api/clean/primitives/operators/matchWithNumber)
+Performs exhaustive matching with raw number keys and passes the narrowed original Clean primitive.
+
### [add](/en/v1/api/clean/primitives/operators/add)
Adds two `Number` (supports the curried version).
diff --git a/docs/en/v1/api/clean/primitives/index.md b/docs/en/v1/api/clean/primitives/index.md
index 31a5529c6..eda387d1e 100644
--- a/docs/en/v1/api/clean/primitives/index.md
+++ b/docs/en/v1/api/clean/primitives/index.md
@@ -96,6 +96,18 @@ function is(
### [equal](/en/v1/api/clean/primitives/operators/equal)
Compares two wrapped primitives (or a primitive and a raw value) with a type guard.
+### [matchWithString](/en/v1/api/clean/primitives/operators/matchWithString)
+Performs exhaustive matching with raw string keys and passes the narrowed original Clean primitive.
+
+### [matchWithStringOtherwise](/en/v1/api/clean/primitives/operators/matchWithStringOtherwise)
+Partially matches raw string keys and passes remaining wrapped values to a typed fallback.
+
+### [matchWithNumber](/en/v1/api/clean/primitives/operators/matchWithNumber)
+Performs exhaustive matching with raw number keys and passes the narrowed original Clean primitive.
+
+### [matchWithNumberOtherwise](/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise)
+Partially matches raw number keys and passes remaining wrapped values to a typed fallback.
+
### [add](/en/v1/api/clean/primitives/operators/add)
Adds two `Number` (supports the curried version).
diff --git a/docs/en/v1/api/clean/primitives/operators/add.md b/docs/en/v1/api/clean/primitives/operators/add.md
index 007a0b4c7..5cbd238d3 100644
--- a/docs/en/v1/api/clean/primitives/operators/add.md
+++ b/docs/en/v1/api/clean/primitives/operators/add.md
@@ -1,8 +1,8 @@
---
outline: [2, 3]
prev:
- text: "equal"
- link: "/en/v1/api/clean/primitives/operators/equal"
+ text: "matchWithNumberOtherwise"
+ link: "/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise"
next:
text: "subtract"
link: "/en/v1/api/clean/primitives/operators/subtract"
diff --git a/docs/en/v1/api/clean/primitives/operators/equal.md b/docs/en/v1/api/clean/primitives/operators/equal.md
index 3b89e3bef..e9266198e 100644
--- a/docs/en/v1/api/clean/primitives/operators/equal.md
+++ b/docs/en/v1/api/clean/primitives/operators/equal.md
@@ -1,8 +1,8 @@
---
outline: [2, 3]
next:
- text: "add"
- link: "/en/v1/api/clean/primitives/operators/add"
+ text: "matchWithString"
+ link: "/en/v1/api/clean/primitives/operators/matchWithString"
---
# equal
diff --git a/docs/en/v1/api/clean/primitives/operators/matchWithNumber.md b/docs/en/v1/api/clean/primitives/operators/matchWithNumber.md
new file mode 100644
index 000000000..7863d8218
--- /dev/null
+++ b/docs/en/v1/api/clean/primitives/operators/matchWithNumber.md
@@ -0,0 +1,59 @@
+---
+outline: [2, 3]
+description: "matchWithNumber() performs exhaustive pattern matching on a Clean number primitive value and passes the correctly narrowed original primitive to each branch."
+prev:
+ text: "matchWithStringOtherwise"
+ link: "/en/v1/api/clean/primitives/operators/matchWithStringOtherwise"
+next:
+ text: "matchWithNumberOtherwise"
+ link: "/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise"
+---
+
+# matchWithNumber
+
+`matchWithNumber()` performs exhaustive pattern matching on the value of a Clean number primitive. Every possible value must have a processing branch.
+
+A Clean primitive is a wrapped object, so it cannot be used directly as a matcher key. The keys are therefore raw `number` values. When a key matches, its callback receives the original Clean primitive narrowed to that value, preserving its `Primitive`, `ConstrainedType`, or `NewType` information.
+
+## Interactive example
+
+
+```
+
+### Curried signature
+
+```typescript
+function matchWithNumber
+```
+
+## Parameters
+
+- `input`: a Clean primitive containing a `number`, including constrained values and new types.
+- `matcher`: an exhaustive object indexed by the possible raw `number` values. A broad `Primitive` requires an indexed `Record`.
+
+Every key must have exactly one handler. TypeScript rejects a missing key or a key outside the input union. The selected handler receives the original Clean object narrowed with `Primitive`.
+
+## Return value
+
+The selected handler result, typed as the union of every handler return type.
+
+## See also
+
+- [`matchWithString`](/en/v1/api/clean/primitives/operators/matchWithString) - String primitive equivalent.
+- [`equal`](/en/v1/api/clean/primitives/operators/equal) - Compares wrapped primitive values.
diff --git a/docs/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md b/docs/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md
new file mode 100644
index 000000000..a5cc03b31
--- /dev/null
+++ b/docs/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithNumberOtherwise() partially matches a Clean number primitive while preserving the narrowed original primitive in handlers and otherwise."
+prev:
+ text: "matchWithNumber"
+ link: "/en/v1/api/clean/primitives/operators/matchWithNumber"
+next:
+ text: "add"
+ link: "/en/v1/api/clean/primitives/operators/add"
+---
+
+# matchWithNumberOtherwise
+
+`matchWithNumberOtherwise()` handles selected values of a Clean number primitive. Raw number values form the matcher keys. Missing cases are sent to `otherwise`, which receives the original primitive narrowed to the remaining values.
+
+## Interactive example
+
+
+```
+
+### Curried signature
+
+```typescript
+function matchWithString
+```
+
+## Parameters
+
+- `input`: a Clean primitive containing a `string`, including constrained values and new types.
+- `matcher`: an exhaustive object indexed by the possible raw `string` values. A broad `Primitive` requires an indexed `Record`.
+
+Every key must have exactly one handler. TypeScript rejects a missing key or a key outside the input union. The selected handler receives the original Clean object narrowed with `Primitive`.
+
+## Return value
+
+The selected handler result, typed as the union of every handler return type.
+
+## See also
+
+- [`matchWithNumber`](/en/v1/api/clean/primitives/operators/matchWithNumber) - Numeric primitive equivalent.
+- [`equal`](/en/v1/api/clean/primitives/operators/equal) - Compares wrapped primitive values.
diff --git a/docs/en/v1/api/clean/primitives/operators/matchWithStringOtherwise.md b/docs/en/v1/api/clean/primitives/operators/matchWithStringOtherwise.md
new file mode 100644
index 000000000..1223953a4
--- /dev/null
+++ b/docs/en/v1/api/clean/primitives/operators/matchWithStringOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithStringOtherwise() partially matches a Clean string primitive while preserving the narrowed original primitive in handlers and otherwise."
+prev:
+ text: "matchWithString"
+ link: "/en/v1/api/clean/primitives/operators/matchWithString"
+next:
+ text: "matchWithNumber"
+ link: "/en/v1/api/clean/primitives/operators/matchWithNumber"
+---
+
+# matchWithStringOtherwise
+
+`matchWithStringOtherwise()` handles selected values of a Clean string primitive. Raw string values form the matcher keys. Missing cases are sent to `otherwise`, which receives the original primitive narrowed to the remaining values.
+
+## Interactive example
+
+ = prepareAsyncPipe()(
+ pipe1,
+ pipe2
+);
+```
+
+## Parameters
+
+- `Input`: optional upper constraint for the direct or promised input.
+- `pipe1, pipe2, ...`: one to fifteen transformations returning either a value or a promise.
+
+## Return value
+
+A reusable function accepting `Input | PromiseLike,
+ GenericOutput,
+>(
+ input: GenericInput,
+ selector: GenericSelector,
+ theFunction: (value: UnwrappedSelectedInputs) => GenericOutput,
+): GenericOutput | UnselectedInputs
+```
+
+### Curried signature
+
+```typescript
+function whenIsSelected<
+ GenericInput extends unknown,
+ GenericSelector extends Record,
+ GenericOutput,
+>(
+ selector: GenericSelector,
+ theFunction: (value: UnwrappedSelectedInputs) => GenericOutput,
+): (input: GenericInput) => GenericOutput | UnselectedInputs
+```
+
+## Parameters
+
+- `selector`: Exhaustive object mapping every possible input information to `true` or `false`.
+- `theFunction`: Callback receiving the unwrapped payload of the selected informations.
+- `input`: Value to process immediately, or later through the curried form.
+
+## Return value
+
+Returns the callback result when the current information is selected with `true`. Otherwise, it returns the original input unchanged.
+
+When a selector entry is typed as `boolean`, the return type includes both the callback result and the original `Either` for that information.
+
+## See also
+
+- [`whenHasInformation`](/en/v1/api/either/whenHasInformation) - Selects one or several informations without an exhaustive selector.
+- [`unwrapSelection`](/en/v1/api/either/unwrapSelection) - Unwraps selected payloads without applying a callback.
+- [`matchInformation`](/en/v1/api/either/matchInformation) - Exhaustive callback-based matching by information.
diff --git a/docs/en/v1/api/pattern/index.md b/docs/en/v1/api/pattern/index.md
index aac156780..af934527c 100644
--- a/docs/en/v1/api/pattern/index.md
+++ b/docs/en/v1/api/pattern/index.md
@@ -28,6 +28,18 @@ import * as P from "@duplojs/utils/pattern";
### [match](/fr/v1/api/pattern/match)
Associates a pattern and a transformation function. Returns a `PatternResult` when the input matches the pattern exactly (primitive, tuple, object, union...).
+### [matchWithString](/en/v1/api/pattern/matchWithString)
+Exhaustively dispatches a string literal union to typed handlers.
+
+### [matchWithStringOtherwise](/en/v1/api/pattern/matchWithStringOtherwise)
+Handles selected string literals and sends remaining cases to a typed fallback.
+
+### [matchWithNumber](/en/v1/api/pattern/matchWithNumber)
+Exhaustively dispatches a number literal union to typed handlers.
+
+### [matchWithNumberOtherwise](/en/v1/api/pattern/matchWithNumberOtherwise)
+Handles selected number literals and sends remaining cases to a typed fallback.
+
### [when](/fr/v1/api/pattern/when)
Adds a guard (type predicate or boolean) in a pipeline. If the condition is true, the associated function is executed and its result is wrapped.
diff --git a/docs/en/v1/api/pattern/match.md b/docs/en/v1/api/pattern/match.md
index 5a372c9f4..c43ce70fe 100644
--- a/docs/en/v1/api/pattern/match.md
+++ b/docs/en/v1/api/pattern/match.md
@@ -5,8 +5,8 @@ prev:
text: "Pattern"
link: "/en/v1/api/pattern/"
next:
- text: "when"
- link: "/en/v1/api/pattern/when"
+ text: "matchWithString"
+ link: "/en/v1/api/pattern/matchWithString"
---
# match
diff --git a/docs/en/v1/api/pattern/matchWithNumber.md b/docs/en/v1/api/pattern/matchWithNumber.md
new file mode 100644
index 000000000..664cc58a6
--- /dev/null
+++ b/docs/en/v1/api/pattern/matchWithNumber.md
@@ -0,0 +1,55 @@
+---
+outline: [2, 3]
+description: "matchWithNumber() performs exhaustive pattern matching on a number literal union and guarantees processing for every possible value."
+prev:
+ text: "matchWithStringOtherwise"
+ link: "/en/v1/api/pattern/matchWithStringOtherwise"
+next:
+ text: "matchWithNumberOtherwise"
+ link: "/en/v1/api/pattern/matchWithNumberOtherwise"
+---
+
+# matchWithNumber
+
+`matchWithNumber()` performs exhaustive pattern matching on a number literal or a union of number literals. Every possible value must have exactly one handler, guaranteeing that no case is left unprocessed. The selected callback receives the literal value corresponding to its key, correctly narrowed by TypeScript.
+
+## Interactive example
+
+
+```
+
+### Curried signature
+
+```typescript
+function matchWithNumber
+```
+
+## Parameters
+
+- `input`: a number literal or a union of number literals. Broad `number` values are rejected.
+- `matcher`: an exhaustive object whose keys are exactly the input literals. Each handler receives its corresponding narrowed literal.
+
+## Return value
+
+The selected handler result. Its static type is the union of all handler return types.
+
+## See also
+
+- [`matchWithString`](/en/v1/api/pattern/matchWithString) - String equivalent.
+- [`match`](/en/v1/api/pattern/match) - General-purpose pattern matching.
diff --git a/docs/en/v1/api/pattern/matchWithNumberOtherwise.md b/docs/en/v1/api/pattern/matchWithNumberOtherwise.md
new file mode 100644
index 000000000..d1e6c3c40
--- /dev/null
+++ b/docs/en/v1/api/pattern/matchWithNumberOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithNumberOtherwise() partially matches a number literal union and sends precisely the unhandled values to an otherwise callback."
+prev:
+ text: "matchWithNumber"
+ link: "/en/v1/api/pattern/matchWithNumber"
+next:
+ text: "when"
+ link: "/en/v1/api/pattern/when"
+---
+
+# matchWithNumberOtherwise
+
+`matchWithNumberOtherwise()` handles selected members of a number literal union. Matcher keys must belong to the input union, but may omit cases. The `otherwise` callback receives only the literals that have no handler.
+
+## Interactive example
+
+
+```
+
+### Curried signature
+
+```typescript
+function matchWithString
+```
+
+## Parameters
+
+- `input`: a string literal or a union of string literals. Broad `string` values are rejected.
+- `matcher`: an exhaustive object whose keys are exactly the input literals. Each handler receives its corresponding narrowed literal.
+
+## Return value
+
+The selected handler result. Its static type is the union of all handler return types.
+
+## See also
+
+- [`matchWithNumber`](/en/v1/api/pattern/matchWithNumber) - Numeric equivalent.
+- [`match`](/en/v1/api/pattern/match) - General-purpose pattern matching.
diff --git a/docs/en/v1/api/pattern/matchWithStringOtherwise.md b/docs/en/v1/api/pattern/matchWithStringOtherwise.md
new file mode 100644
index 000000000..c11fa1b75
--- /dev/null
+++ b/docs/en/v1/api/pattern/matchWithStringOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithStringOtherwise() partially matches a string literal union and sends precisely the unhandled values to an otherwise callback."
+prev:
+ text: "matchWithString"
+ link: "/en/v1/api/pattern/matchWithString"
+next:
+ text: "matchWithNumber"
+ link: "/en/v1/api/pattern/matchWithNumber"
+---
+
+# matchWithStringOtherwise
+
+`matchWithStringOtherwise()` handles selected members of a string literal union. Matcher keys must belong to the input union, but may omit cases. The `otherwise` callback receives only the literals that have no handler.
+
+## Interactive example
+
+;
diff --git a/docs/examples/v1/api/clean/primitives/operators/matchWithStringOtherwise/tryout.doc.ts b/docs/examples/v1/api/clean/primitives/operators/matchWithStringOtherwise/tryout.doc.ts
new file mode 100644
index 000000000..2e2cc374f
--- /dev/null
+++ b/docs/examples/v1/api/clean/primitives/operators/matchWithStringOtherwise/tryout.doc.ts
@@ -0,0 +1,25 @@
+import { DClean, type ExpectType, pipe, unwrap } from "@duplojs/utils";
+
+const status = DClean.String.createOrThrow(
+ "failure" as "success" | "failure" | "pending",
+);
+
+const result = pipe(
+ status,
+ DClean.matchWithStringOtherwise(
+ {
+ success: () => 200 as const,
+ },
+ (value) => {
+ type check = ExpectType<
+ typeof value,
+ DClean.Primitive<"success" | "failure" | "pending">
+ & DClean.Primitive<"failure" | "pending">,
+ "strict"
+ >;
+ return value;
+ },
+ ),
+);
+
+console.log(unwrap(result)); // "failure"
diff --git a/docs/examples/v1/api/common/prepareAsyncPipe/tryout.doc.ts b/docs/examples/v1/api/common/prepareAsyncPipe/tryout.doc.ts
new file mode 100644
index 000000000..533d40731
--- /dev/null
+++ b/docs/examples/v1/api/common/prepareAsyncPipe/tryout.doc.ts
@@ -0,0 +1,36 @@
+import { type ExpectType, prepareAsyncPipe, DString } from "@duplojs/utils";
+
+const numberToString: (
+ input: number
+) => Promise = prepareAsyncPipe()(
+ async(value) => Promise.resolve(value),
+ DString.to,
+);
+
+const firstResult = await numberToString(10);
+const secondResult = await numberToString(
+ await Promise.resolve(42),
+);
+
+type firstCheck = ExpectType<
+ typeof firstResult,
+ string,
+ "strict"
+>;
+
+console.log(firstResult); // "10"
+console.log(secondResult); // "42"
+
+const explicitlyTypedPipe = prepareAsyncPipe()(
+ async(value) => Promise.resolve(value * 2),
+ DString.to,
+);
+const explicitResult = await explicitlyTypedPipe(21);
+
+type explicitCheck = ExpectType<
+ typeof explicitResult,
+ `${number}`,
+ "strict"
+>;
+
+console.log(explicitResult); // "42"
diff --git a/docs/examples/v1/api/common/preparePipe/tryout.doc.ts b/docs/examples/v1/api/common/preparePipe/tryout.doc.ts
new file mode 100644
index 000000000..bb5bf6651
--- /dev/null
+++ b/docs/examples/v1/api/common/preparePipe/tryout.doc.ts
@@ -0,0 +1,31 @@
+import { type ExpectType, preparePipe, DString } from "@duplojs/utils";
+
+const numberToString: (input: number) => string = preparePipe()(
+ DString.to,
+);
+
+const firstResult = numberToString(10);
+const secondResult = numberToString(42);
+
+type firstCheck = ExpectType<
+ typeof firstResult,
+ string,
+ "strict"
+>;
+
+console.log(firstResult); // "10"
+console.log(secondResult); // "42"
+
+const explicitlyTypedPipe = preparePipe()(
+ (value) => value * 2,
+ DString.to,
+);
+const explicitResult = explicitlyTypedPipe(21);
+
+type explicitCheck = ExpectType<
+ typeof explicitResult,
+ `${number}`,
+ "strict"
+>;
+
+console.log(explicitResult); // "42"
diff --git a/docs/examples/v1/api/either/whenIsSelected/tryout.doc.ts b/docs/examples/v1/api/either/whenIsSelected/tryout.doc.ts
new file mode 100644
index 000000000..926e0bff1
--- /dev/null
+++ b/docs/examples/v1/api/either/whenIsSelected/tryout.doc.ts
@@ -0,0 +1,37 @@
+import { E, pipe, type ExpectType } from "@duplojs/utils";
+
+const payment = true
+ ? E.right("payment.accepted", 120 as const)
+ : E.left("payment.rejected", "insufficient funds" as const);
+
+const formattedPayment = E.whenIsSelected(
+ payment,
+ {
+ "payment.accepted": true,
+ "payment.rejected": false,
+ },
+ (amount) => `paid:${amount}` as const,
+);
+
+type formattedPaymentCheck = ExpectType<
+ typeof formattedPayment,
+ "paid:120" | E.Left<"payment.rejected", "insufficient funds">,
+ "strict"
+>;
+
+const pipedPayment = pipe(
+ payment,
+ E.whenIsSelected(
+ {
+ "payment.accepted": true,
+ "payment.rejected": false,
+ },
+ (amount) => ({ amount }),
+ ),
+);
+
+type pipedPaymentCheck = ExpectType<
+ typeof pipedPayment,
+ { readonly amount: 120 } | E.Left<"payment.rejected", "insufficient funds">,
+ "strict"
+>;
diff --git a/docs/examples/v1/api/pattern/matchWithNumber/tryout.doc.ts b/docs/examples/v1/api/pattern/matchWithNumber/tryout.doc.ts
new file mode 100644
index 000000000..0ecf8a80b
--- /dev/null
+++ b/docs/examples/v1/api/pattern/matchWithNumber/tryout.doc.ts
@@ -0,0 +1,25 @@
+import { DPattern, pipe, type ExpectType } from "@duplojs/utils";
+
+const status = 200 as 200 | 404;
+
+const result = pipe(
+ status,
+ DPattern.matchWithNumber({
+ 200: (value) => {
+ type check = ExpectType<
+ typeof value,
+ 200,
+ "strict"
+ >;
+
+ return "success" as const;
+ },
+ 404: () => "missing" as const,
+ }),
+);
+
+type check = ExpectType<
+ typeof result,
+ "success" | "missing",
+ "strict"
+>;
diff --git a/docs/examples/v1/api/pattern/matchWithNumberOtherwise/tryout.doc.ts b/docs/examples/v1/api/pattern/matchWithNumberOtherwise/tryout.doc.ts
new file mode 100644
index 000000000..c71274023
--- /dev/null
+++ b/docs/examples/v1/api/pattern/matchWithNumberOtherwise/tryout.doc.ts
@@ -0,0 +1,21 @@
+import { DPattern, type ExpectType, pipe } from "@duplojs/utils";
+
+const status = 404 as 200 | 404 | 500;
+
+const result = pipe(
+ status,
+ DPattern.matchWithNumberOtherwise(
+ {
+ 200: (value) => {
+ type check = ExpectType;
+ return "success" as const;
+ },
+ },
+ (value) => {
+ type check = ExpectType;
+ return `error: ${value}`;
+ },
+ ),
+);
+
+console.log(result); // "error: 404"
diff --git a/docs/examples/v1/api/pattern/matchWithString/tryout.doc.ts b/docs/examples/v1/api/pattern/matchWithString/tryout.doc.ts
new file mode 100644
index 000000000..a19c86378
--- /dev/null
+++ b/docs/examples/v1/api/pattern/matchWithString/tryout.doc.ts
@@ -0,0 +1,25 @@
+import { DPattern, pipe, type ExpectType } from "@duplojs/utils";
+
+const status = "success" as "success" | "failure";
+
+const result = pipe(
+ status,
+ DPattern.matchWithString({
+ success: (value) => {
+ type check = ExpectType<
+ typeof value,
+ "success",
+ "strict"
+ >;
+
+ return 200 as const;
+ },
+ failure: () => 500 as const,
+ }),
+);
+
+type check = ExpectType<
+ typeof result,
+ 200 | 500,
+ "strict"
+>;
diff --git a/docs/examples/v1/api/pattern/matchWithStringOtherwise/tryout.doc.ts b/docs/examples/v1/api/pattern/matchWithStringOtherwise/tryout.doc.ts
new file mode 100644
index 000000000..2c1cec5a0
--- /dev/null
+++ b/docs/examples/v1/api/pattern/matchWithStringOtherwise/tryout.doc.ts
@@ -0,0 +1,21 @@
+import { DPattern, type ExpectType, pipe } from "@duplojs/utils";
+
+const status = "failure" as "success" | "failure" | "pending";
+
+const result = pipe(
+ status,
+ DPattern.matchWithStringOtherwise(
+ {
+ success: (value) => {
+ type check = ExpectType;
+ return 200 as const;
+ },
+ },
+ (value) => {
+ type check = ExpectType;
+ return `unhandled: ${value}`;
+ },
+ ),
+);
+
+console.log(result); // "unhandled: failure"
diff --git a/docs/fr/v1/api/clean/index.md b/docs/fr/v1/api/clean/index.md
index fe141626c..cce9356bb 100644
--- a/docs/fr/v1/api/clean/index.md
+++ b/docs/fr/v1/api/clean/index.md
@@ -69,6 +69,12 @@ Déclare un agrégat d'actions métier liées qui doivent s'exécuter dans l'ord
### [equal](/fr/v1/api/clean/primitives/operators/equal)
Compare deux primitives wrappées (ou une primitive et une valeur brute) avec un type guard.
+### [matchWithString](/fr/v1/api/clean/primitives/operators/matchWithString)
+Effectue un matching exhaustif avec des clés string brutes et transmet la primitive Clean originale affinée.
+
+### [matchWithNumber](/fr/v1/api/clean/primitives/operators/matchWithNumber)
+Effectue un matching exhaustif avec des clés number brutes et transmet la primitive Clean originale affinée.
+
### [add](/fr/v1/api/clean/primitives/operators/add)
Additionne deux `Number` (supporte la version currifiée).
diff --git a/docs/fr/v1/api/clean/primitives/index.md b/docs/fr/v1/api/clean/primitives/index.md
index 6c6fba9fb..83a0fb9d3 100644
--- a/docs/fr/v1/api/clean/primitives/index.md
+++ b/docs/fr/v1/api/clean/primitives/index.md
@@ -96,6 +96,18 @@ function is(
### [equal](/fr/v1/api/clean/primitives/operators/equal)
Compare deux primitives wrappées (ou une primitive et une valeur brute) avec un type guard.
+### [matchWithString](/fr/v1/api/clean/primitives/operators/matchWithString)
+Effectue un matching exhaustif avec des clés string brutes et transmet la primitive Clean originale affinée.
+
+### [matchWithStringOtherwise](/fr/v1/api/clean/primitives/operators/matchWithStringOtherwise)
+Effectue un matching partiel avec des clés string brutes et transmet les valeurs restantes à un fallback typé.
+
+### [matchWithNumber](/fr/v1/api/clean/primitives/operators/matchWithNumber)
+Effectue un matching exhaustif avec des clés number brutes et transmet la primitive Clean originale affinée.
+
+### [matchWithNumberOtherwise](/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise)
+Effectue un matching partiel avec des clés number brutes et transmet les valeurs restantes à un fallback typé.
+
### [add](/fr/v1/api/clean/primitives/operators/add)
Additionne deux `Number` (supporte la version currifiée).
diff --git a/docs/fr/v1/api/clean/primitives/operators/add.md b/docs/fr/v1/api/clean/primitives/operators/add.md
index 48819caa8..5aab403f3 100644
--- a/docs/fr/v1/api/clean/primitives/operators/add.md
+++ b/docs/fr/v1/api/clean/primitives/operators/add.md
@@ -1,8 +1,8 @@
---
outline: [2, 3]
prev:
- text: "equal"
- link: "/fr/v1/api/clean/primitives/operators/equal"
+ text: "matchWithNumberOtherwise"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise"
next:
text: "subtract"
link: "/fr/v1/api/clean/primitives/operators/subtract"
diff --git a/docs/fr/v1/api/clean/primitives/operators/equal.md b/docs/fr/v1/api/clean/primitives/operators/equal.md
index ac648fe93..e35b265b0 100644
--- a/docs/fr/v1/api/clean/primitives/operators/equal.md
+++ b/docs/fr/v1/api/clean/primitives/operators/equal.md
@@ -1,8 +1,8 @@
---
outline: [2, 3]
next:
- text: "add"
- link: "/fr/v1/api/clean/primitives/operators/operators/add"
+ text: "matchWithString"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithString"
---
# equal
diff --git a/docs/fr/v1/api/clean/primitives/operators/matchWithNumber.md b/docs/fr/v1/api/clean/primitives/operators/matchWithNumber.md
new file mode 100644
index 000000000..2462c1ced
--- /dev/null
+++ b/docs/fr/v1/api/clean/primitives/operators/matchWithNumber.md
@@ -0,0 +1,59 @@
+---
+outline: [2, 3]
+description: "matchWithNumber() effectue un pattern matching exhaustif sur la valeur d’une primitive Clean number et transmet à chaque branche la primitive originale correctement affinée."
+prev:
+ text: "matchWithStringOtherwise"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithStringOtherwise"
+next:
+ text: "matchWithNumberOtherwise"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise"
+---
+
+# matchWithNumber
+
+`matchWithNumber()` effectue un pattern matching exhaustif sur la valeur d’une primitive Clean number. Chaque valeur possible doit avoir une branche de traitement.
+
+Une primitive Clean étant un objet wrappé, elle ne peut pas servir directement de clé au matcher. Les clés sont donc les valeurs `number` brutes. Lorsqu’une clé correspond, son callback reçoit la primitive Clean originale, affinée sur cette valeur. Ses informations `Primitive`, `ConstrainedType` ou `NewType` sont ainsi conservées.
+
+## Exemple interactif
+
+
+```
+
+### Signature currifiée
+
+```typescript
+function matchWithNumber
+```
+
+## Paramètres
+
+- `input` : une primitive Clean contenant une valeur `number`, y compris une valeur contrainte ou un new type.
+- `matcher` : un objet exhaustif indexé par les valeurs `number` brutes possibles. Une `Primitive` large nécessite un `Record` indexé.
+
+Chaque clé doit avoir exactement un handler. Une clé manquante ou étrangère à l’union est refusée par TypeScript. Le handler sélectionné reçoit l’objet Clean original affiné avec `Primitive`.
+
+## Valeur de retour
+
+Le résultat du handler sélectionné, typé comme l’union des retours de tous les handlers.
+
+## Voir aussi
+
+- [`matchWithString`](/fr/v1/api/clean/primitives/operators/matchWithString) - Équivalent pour les primitives string.
+- [`equal`](/fr/v1/api/clean/primitives/operators/equal) - Compare les valeurs de primitives wrappées.
diff --git a/docs/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md b/docs/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md
new file mode 100644
index 000000000..127df61fe
--- /dev/null
+++ b/docs/fr/v1/api/clean/primitives/operators/matchWithNumberOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithNumberOtherwise() traite partiellement une primitive Clean number tout en préservant la primitive originale affinée dans les handlers et otherwise."
+prev:
+ text: "matchWithNumber"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithNumber"
+next:
+ text: "add"
+ link: "/fr/v1/api/clean/primitives/operators/add"
+---
+
+# matchWithNumberOtherwise
+
+`matchWithNumberOtherwise()` traite certaines valeurs d’une primitive Clean number. Les valeurs number brutes forment les clés du matcher. Les cas manquants sont transmis à `otherwise`, qui reçoit la primitive originale affinée sur les valeurs restantes.
+
+## Exemple interactif
+
+
+```
+
+### Signature currifiée
+
+```typescript
+function matchWithString
+```
+
+## Paramètres
+
+- `input` : une primitive Clean contenant une valeur `string`, y compris une valeur contrainte ou un new type.
+- `matcher` : un objet exhaustif indexé par les valeurs `string` brutes possibles. Une `Primitive` large nécessite un `Record` indexé.
+
+Chaque clé doit avoir exactement un handler. Une clé manquante ou étrangère à l’union est refusée par TypeScript. Le handler sélectionné reçoit l’objet Clean original affiné avec `Primitive`.
+
+## Valeur de retour
+
+Le résultat du handler sélectionné, typé comme l’union des retours de tous les handlers.
+
+## Voir aussi
+
+- [`matchWithNumber`](/fr/v1/api/clean/primitives/operators/matchWithNumber) - Équivalent pour les primitives numériques.
+- [`equal`](/fr/v1/api/clean/primitives/operators/equal) - Compare les valeurs de primitives wrappées.
diff --git a/docs/fr/v1/api/clean/primitives/operators/matchWithStringOtherwise.md b/docs/fr/v1/api/clean/primitives/operators/matchWithStringOtherwise.md
new file mode 100644
index 000000000..ca90e1d57
--- /dev/null
+++ b/docs/fr/v1/api/clean/primitives/operators/matchWithStringOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithStringOtherwise() traite partiellement une primitive Clean string tout en préservant la primitive originale affinée dans les handlers et otherwise."
+prev:
+ text: "matchWithString"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithString"
+next:
+ text: "matchWithNumber"
+ link: "/fr/v1/api/clean/primitives/operators/matchWithNumber"
+---
+
+# matchWithStringOtherwise
+
+`matchWithStringOtherwise()` traite certaines valeurs d’une primitive Clean string. Les valeurs string brutes forment les clés du matcher. Les cas manquants sont transmis à `otherwise`, qui reçoit la primitive originale affinée sur les valeurs restantes.
+
+## Exemple interactif
+
+ = prepareAsyncPipe()(
+ pipe1,
+ pipe2
+);
+```
+
+## Paramètres
+
+- `Input` : contrainte supérieure optionnelle de l’entrée directe ou promise.
+- `pipe1, pipe2, ...` : une à quinze transformations retournant une valeur ou une promesse.
+
+## Valeur de retour
+
+Une fonction réutilisable acceptant `Input | PromiseLike,
+ GenericOutput,
+>(
+ input: GenericInput,
+ selector: GenericSelector,
+ theFunction: (value: UnwrappedSelectedInputs) => GenericOutput,
+): GenericOutput | UnselectedInputs
+```
+
+### Signature currifiée
+
+```typescript
+function whenIsSelected<
+ GenericInput extends unknown,
+ GenericSelector extends Record,
+ GenericOutput,
+>(
+ selector: GenericSelector,
+ theFunction: (value: UnwrappedSelectedInputs) => GenericOutput,
+): (input: GenericInput) => GenericOutput | UnselectedInputs
+```
+
+## Paramètres
+
+- `selector` : Objet exhaustif associant chaque information possible de l'entrée à `true` ou `false`.
+- `theFunction` : Callback recevant le payload unwrap des informations sélectionnées.
+- `input` : Valeur à traiter immédiatement, ou plus tard via la forme currifiée.
+
+## Valeur de retour
+
+Retourne le résultat du callback lorsque l'information courante est sélectionnée avec `true`. Sinon, renvoie l'entrée originale inchangée.
+
+Quand une entrée du sélecteur est typée `boolean`, le type de retour inclut à la fois le résultat du callback et l'`Either` original pour cette information.
+
+## Voir aussi
+
+- [`whenHasInformation`](/fr/v1/api/either/whenHasInformation) - Sélectionne une ou plusieurs informations sans sélecteur exhaustif.
+- [`unwrapSelection`](/fr/v1/api/either/unwrapSelection) - Unwrap les payloads sélectionnés sans appliquer de callback.
+- [`matchInformation`](/fr/v1/api/either/matchInformation) - Matching exhaustif par information avec callbacks.
diff --git a/docs/fr/v1/api/pattern/index.md b/docs/fr/v1/api/pattern/index.md
index 32119363f..aa006768a 100644
--- a/docs/fr/v1/api/pattern/index.md
+++ b/docs/fr/v1/api/pattern/index.md
@@ -28,6 +28,18 @@ import * as P from "@duplojs/utils/pattern";
### [match](/fr/v1/api/pattern/match)
Associe un motif et une fonction de transformation. Retourne un `PatternResult` quand l'entrée correspond exactement au motif (primitive, tuple, objet, union...).
+### [matchWithString](/fr/v1/api/pattern/matchWithString)
+Distribue exhaustivement une union de chaînes littérales vers des handlers typés.
+
+### [matchWithStringOtherwise](/fr/v1/api/pattern/matchWithStringOtherwise)
+Traite certaines chaînes littérales et transmet les cas restants à un fallback typé.
+
+### [matchWithNumber](/fr/v1/api/pattern/matchWithNumber)
+Distribue exhaustivement une union de nombres littéraux vers des handlers typés.
+
+### [matchWithNumberOtherwise](/fr/v1/api/pattern/matchWithNumberOtherwise)
+Traite certains nombres littéraux et transmet les cas restants à un fallback typé.
+
### [when](/fr/v1/api/pattern/when)
Ajoute une garde (type predicate ou boolean) dans un pipeline. Si la condition est vraie, la fonction associée est exécutée et son résultat est encapsulé.
diff --git a/docs/fr/v1/api/pattern/match.md b/docs/fr/v1/api/pattern/match.md
index ddde9f46c..f0e57bb0d 100644
--- a/docs/fr/v1/api/pattern/match.md
+++ b/docs/fr/v1/api/pattern/match.md
@@ -5,8 +5,8 @@ prev:
text: "Pattern"
link: "/fr/v1/api/pattern/"
next:
- text: "when"
- link: "/fr/v1/api/pattern/when"
+ text: "matchWithString"
+ link: "/fr/v1/api/pattern/matchWithString"
---
# match
diff --git a/docs/fr/v1/api/pattern/matchWithNumber.md b/docs/fr/v1/api/pattern/matchWithNumber.md
new file mode 100644
index 000000000..dd1317217
--- /dev/null
+++ b/docs/fr/v1/api/pattern/matchWithNumber.md
@@ -0,0 +1,55 @@
+---
+outline: [2, 3]
+description: "matchWithNumber() effectue un pattern matching exhaustif sur une union de nombres littéraux et garantit un traitement pour chaque valeur possible."
+prev:
+ text: "matchWithStringOtherwise"
+ link: "/fr/v1/api/pattern/matchWithStringOtherwise"
+next:
+ text: "matchWithNumberOtherwise"
+ link: "/fr/v1/api/pattern/matchWithNumberOtherwise"
+---
+
+# matchWithNumber
+
+`matchWithNumber()` effectue un pattern matching exhaustif sur un nombre littéral ou une union de nombres littéraux. Chaque valeur possible doit posséder exactement un handler, ce qui garantit qu’aucun cas ne reste sans traitement. Le callback sélectionné reçoit la valeur littérale correspondant à sa clé, correctement affinée par TypeScript.
+
+## Exemple interactif
+
+
+```
+
+### Signature currifiée
+
+```typescript
+function matchWithNumber
+```
+
+## Paramètres
+
+- `input` : un nombre littéral ou une union de nombres littéraux. Le type large `number` est refusé.
+- `matcher` : un objet exhaustif dont les clés correspondent exactement aux littéraux d’entrée. Chaque handler reçoit son littéral correctement affiné.
+
+## Valeur de retour
+
+Le résultat du handler sélectionné. Son type statique est l’union des retours de tous les handlers.
+
+## Voir aussi
+
+- [`matchWithString`](/fr/v1/api/pattern/matchWithString) - Équivalent pour les chaînes.
+- [`match`](/fr/v1/api/pattern/match) - Pattern matching généraliste.
diff --git a/docs/fr/v1/api/pattern/matchWithNumberOtherwise.md b/docs/fr/v1/api/pattern/matchWithNumberOtherwise.md
new file mode 100644
index 000000000..73358e97c
--- /dev/null
+++ b/docs/fr/v1/api/pattern/matchWithNumberOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithNumberOtherwise() traite partiellement une union de nombres littéraux et transmet précisément les valeurs non traitées à un callback otherwise."
+prev:
+ text: "matchWithNumber"
+ link: "/fr/v1/api/pattern/matchWithNumber"
+next:
+ text: "when"
+ link: "/fr/v1/api/pattern/when"
+---
+
+# matchWithNumberOtherwise
+
+`matchWithNumberOtherwise()` traite certains membres d’une union de nombres littéraux. Les clés du matcher doivent appartenir à l’union d’entrée, mais certains cas peuvent être omis. Le callback `otherwise` reçoit uniquement les littéraux sans handler.
+
+## Exemple interactif
+
+
+```
+
+### Signature currifiée
+
+```typescript
+function matchWithString
+```
+
+## Paramètres
+
+- `input` : une chaîne littérale ou une union de chaînes littérales. Le type large `string` est refusé.
+- `matcher` : un objet exhaustif dont les clés correspondent exactement aux littéraux d’entrée. Chaque handler reçoit son littéral correctement affiné.
+
+## Valeur de retour
+
+Le résultat du handler sélectionné. Son type statique est l’union des retours de tous les handlers.
+
+## Voir aussi
+
+- [`matchWithNumber`](/fr/v1/api/pattern/matchWithNumber) - Équivalent numérique.
+- [`match`](/fr/v1/api/pattern/match) - Pattern matching généraliste.
diff --git a/docs/fr/v1/api/pattern/matchWithStringOtherwise.md b/docs/fr/v1/api/pattern/matchWithStringOtherwise.md
new file mode 100644
index 000000000..59ee7aa40
--- /dev/null
+++ b/docs/fr/v1/api/pattern/matchWithStringOtherwise.md
@@ -0,0 +1,58 @@
+---
+outline: [2, 3]
+description: "matchWithStringOtherwise() traite partiellement une union de chaînes littérales et transmet précisément les valeurs non traitées à un callback otherwise."
+prev:
+ text: "matchWithString"
+ link: "/fr/v1/api/pattern/matchWithString"
+next:
+ text: "matchWithNumber"
+ link: "/fr/v1/api/pattern/matchWithNumber"
+---
+
+# matchWithStringOtherwise
+
+`matchWithStringOtherwise()` traite certains membres d’une union de chaînes littérales. Les clés du matcher doivent appartenir à l’union d’entrée, mais certains cas peuvent être omis. Le callback `otherwise` reçoit uniquement les littéraux sans handler.
+
+## Exemple interactif
+
+>>;
export interface Evidence extends Kind> {
}
+declare const ArrayWithEvidence_base: import("../common").KindClass>>, ArrayConstructor>;
+export declare class ArrayWithEvidence extends ArrayWithEvidence_base> {
+ constructor(array: readonly GenericElement[], evidence: Record);
+ static [Symbol.species]: ArrayConstructor;
+}
/**
* Appends an evidence trait on an object value to mark that a business step was completed.
*
@@ -110,3 +115,4 @@ export declare function appendEvidence>>, string>>(evidenceName: GenericEvidenceName | AnyTuple): (input: GenericInput) => input is Extract : never>;
export declare function hasEvidence>>, string>>(input: GenericInput, evidenceName: GenericEvidenceName | AnyTuple): input is Extract : never>;
export type GetEvidenceResult> extends infer InferredResult ? InferredResult extends Evidence ? InferredResult : InferredResult extends DEither.Right | DEither.Left ? Unwrap : InferredResult : never, Evidence>>>, string>> = Extract> extends infer InferredResult ? InferredResult extends Evidence ? InferredResult : InferredResult extends DEither.Right | DEither.Left ? Unwrap : InferredResult : never, EvidenceName extends any ? Evidence : never>;
+export {};
diff --git a/docs/public/libs/v1/clean/evidence.mjs b/docs/public/libs/v1/clean/evidence.mjs
index 166a4f2a1..cce7aa898 100644
--- a/docs/public/libs/v1/clean/evidence.mjs
+++ b/docs/public/libs/v1/clean/evidence.mjs
@@ -1,6 +1,13 @@
import { createCleanKind } from './kind.mjs';
+import { kindClass } from '../common/kindClass.mjs';
const evidenceKind = createCleanKind("evidence");
+class ArrayWithEvidence extends kindClass(evidenceKind, Array) {
+ constructor(array, evidence) {
+ super(evidence, ...array);
+ }
+ static [Symbol.species] = Array;
+}
function appendEvidence(...args) {
if (args.length === 1) {
const [evidenceName] = args;
@@ -11,6 +18,9 @@ function appendEvidence(...args) {
...(evidenceKind.has(input) && evidenceKind.getValue(input)),
[evidenceName]: null,
};
+ if (input instanceof Array) {
+ return new ArrayWithEvidence(input, evidence);
+ }
return evidenceKind.addTo(input, evidence);
}
function hasEvidence(...args) {
@@ -34,4 +44,4 @@ function hasEvidence(...args) {
return false;
}
-export { appendEvidence, evidenceKind, hasEvidence };
+export { ArrayWithEvidence, appendEvidence, evidenceKind, hasEvidence };
diff --git a/docs/public/libs/v1/clean/flag.d.ts b/docs/public/libs/v1/clean/flag.d.ts
index f54b71669..9176e598a 100644
--- a/docs/public/libs/v1/clean/flag.d.ts
+++ b/docs/public/libs/v1/clean/flag.d.ts
@@ -32,17 +32,26 @@ export interface FlagHandler>(entity: GenericInputEntity): GetKindValue[GenericName];
+ /**
+ * Checks whether the entity has this state and narrows its type to include the flag.
+ *
+ * ```ts
+ * User.MajorFlag.has(user); // false
+ * User.MajorFlag.has(flagged); // true
+ * ```
+ *
+ */
has(entity: GenericInputEntity): entity is Extract>;
}
export interface Flag extends Kind> {
}
/**
- * Creates a flag handler that can attach typed metadata to an entity.
+ * Creates a handler for assigning a typed business state to an entity.
*
* **Supported call styles:**
* - Classic: `createFlag(name)` -> returns a handler
*
- * Flags let you mark an entity after creation without changing its shape. The mark can optionally carry a value.
+ * Use flags to make an entity state part of a precise type contract. Functions can require an entity combined with one or more flags, while the same entity keeps its original business properties and can reuse its repositories, mappers, and other supporting code. A flag can optionally carry data associated with its state.
*
* ```ts
* namespace User {
@@ -97,10 +106,12 @@ export interface Flag matcher[unwrap.unwrap(input)](input);
+ }
+ const [input, matcher] = args;
+ return matcher[unwrap.unwrap(input)](input);
+}
+
+exports.matchWithNumber = matchWithNumber;
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.d.ts b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.d.ts
new file mode 100644
index 000000000..1774bbc0c
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.d.ts
@@ -0,0 +1,55 @@
+import { type ComputedTypeError, type FixDeepFunctionInfer, type IsEqual, type Unwrap } from "../../../common";
+import { type Primitive } from "../base";
+import { type OnlyLiteralPrimitiveNumber } from "../../../clean/types/onlyLiteral";
+type ComputeMatcher> = {
+ [Prop in Unwrap]: (value: GenericInput & Primitive) => unknown;
+};
+type ForbiddenMoreKey, GenericMatcher extends ComputeMatcher> = Exclude> extends infer InferredKey ? IsEqual extends true ? unknown : ComputedTypeError<`Key "${Extract}" is forbidden.`> : never;
+/**
+ * Performs exhaustive pattern matching on the value of a Clean number primitive.
+ *
+ * **Supported call styles:**
+ * - Classic: `matchWithNumber(input, matcher)` -> runs the handler matching the wrapped value
+ * - Curried: `matchWithNumber(matcher)` -> returns a function waiting for the primitive
+ *
+ * A Clean primitive cannot be used directly as an object key, so the matcher uses raw number values as keys. Every possible value must have a handler. The selected handler receives the original Clean primitive narrowed to the matching key, preserving its constraints and `NewType` metadata.
+ *
+ * ```ts
+ * const status = C.Number.createOrThrow(
+ * 200 as 200 | 404,
+ * );
+ *
+ * C.matchWithNumber(status, {
+ * 200: () => "success",
+ * 404: () => "missing",
+ * }); // "success" | "missing"
+ *
+ * pipe(
+ * status,
+ * C.matchWithNumber({
+ * 200: (value) => value,
+ * 404: () => status,
+ * }),
+ * ); // C.Primitive<200 | 404>
+ *
+ * const positiveStatus = C.Positive.createOrThrow(
+ * 200 as 200 | 404,
+ * );
+ *
+ * C.matchWithNumber(positiveStatus, {
+ * 200: (value) => value,
+ * 404: (value) => value,
+ * }); // C.ConstrainedType<"positive", 200 | 404>
+ * ```
+ *
+ * @remarks A broad `Primitive` is supported with a `Record` matcher. Literal unions reject missing and additional keys.
+ *
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithNumber
+ * @see [`C.matchWithString`](https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithString)
+ *
+ * @namespace C
+ *
+ */
+export declare function matchWithNumber, GenericMatcher extends ComputeMatcher>(matcher: FixDeepFunctionInfer>, GenericMatcher> & ForbiddenMoreKey, GenericMatcher>): (input: GenericInput & OnlyLiteralPrimitiveNumber) => ReturnType[keyof GenericMatcher]>;
+export declare function matchWithNumber, GenericMatcher extends ComputeMatcher>(input: GenericInput & OnlyLiteralPrimitiveNumber, matcher: FixDeepFunctionInfer, GenericMatcher> & ForbiddenMoreKey): ReturnType;
+export {};
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.mjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.mjs
new file mode 100644
index 000000000..0886b3ecf
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumber.mjs
@@ -0,0 +1,12 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+
+function matchWithNumber(...args) {
+ if (args.length === 1) {
+ const [matcher] = args;
+ return (input) => matcher[unwrap(input)](input);
+ }
+ const [input, matcher] = args;
+ return matcher[unwrap(input)](input);
+}
+
+export { matchWithNumber };
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.cjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.cjs
new file mode 100644
index 000000000..9d9131cc9
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.cjs
@@ -0,0 +1,18 @@
+'use strict';
+
+var unwrap = require('../../../common/unwrap.cjs');
+
+function execute(input, matcher, otherwise) {
+ const callback = matcher[unwrap.unwrap(input)];
+ return callback === undefined ? otherwise(input) : callback(input);
+}
+function matchWithNumberOtherwise(...args) {
+ if (args.length === 2) {
+ const [matcher, otherwise] = args;
+ return (input) => execute(input, matcher, otherwise);
+ }
+ const [input, matcher, otherwise] = args;
+ return execute(input, matcher, otherwise);
+}
+
+exports.matchWithNumberOtherwise = matchWithNumberOtherwise;
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.d.ts b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.d.ts
new file mode 100644
index 000000000..fb230ff65
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.d.ts
@@ -0,0 +1,61 @@
+import { type AnyFunction, type ComputedTypeError, type FixDeepFunctionInfer, type IsEqual, type Unwrap } from "../../../common";
+import { type GetPropsWithValueExtends } from "../../../object";
+import { type OnlyLiteralPrimitiveNumber } from "../../../clean/types/onlyLiteral";
+import { type Primitive } from "../base";
+type ComputeMatcher> = {
+ [Prop in Unwrap]?: (value: GenericInput & Primitive) => unknown;
+};
+type ForbiddenMoreKey, GenericMatcher extends ComputeMatcher> = Exclude> extends infer InferredKey ? IsEqual extends true ? unknown : ComputedTypeError<`Key "${Extract}" is forbidden.`> : never;
+type HandledKeys = Extract, number>;
+type OtherwiseValue, GenericMatcher extends object> = Extract, HandledKeys>>, any>;
+/** Performs partial pattern matching on a Clean number primitive and delegates unhandled values to an `otherwise` callback.
+/**
+/** **Supported call styles:**
+/** - Classic: `matchWithNumberOtherwise(input, matcher, otherwise)` -> runs a matching handler or the fallback
+/** - Curried: `matchWithNumberOtherwise(matcher, otherwise)` -> returns a function waiting for the primitive
+/**
+/** Raw number values are used as matcher keys. Handlers receive the original primitive narrowed to their key, and `otherwise` receives the same original primitive narrowed to all remaining values.
+/**
+/** ```ts
+/** const status = C.Number.createOrThrow(
+/** 200 as 200 | 404 | 500,
+/** );
+/**
+/** C.matchWithNumberOtherwise(
+/** status,
+/** {
+/** 200: () => "success",
+/** },
+/** () => "error",
+/** ); // string
+/**
+/** pipe(
+/** status,
+/** C.matchWithNumberOtherwise(
+/** {
+/** 404: () => "missing",
+/** },
+/** (value) => value,
+/** ),
+/** ); // "missing" | C.Primitive<200 | 500>
+/**
+/** const result = C.matchWithNumberOtherwise(
+/** status,
+/** {
+/** 200: (value) => value,
+/** 404: undefined,
+/** },
+/** (value) => value,
+/** ); // C.Primitive<200 | 404 | 500>
+/** ```
+/**
+/** @remarks Constraints and `NewType` metadata remain attached to the primitive passed to every callback.
+/**
+/** @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithNumberOtherwise
+/** @see [`C.matchWithNumber`](https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithNumber)
+/**
+/** @namespace C
+/** */
+export declare function matchWithNumberOtherwise, GenericMatcher extends ComputeMatcher, GenericOutput>(matcher: FixDeepFunctionInfer>, GenericMatcher> & ForbiddenMoreKey, GenericMatcher>, otherwise: (value: OtherwiseValue) => GenericOutput): (input: GenericInput & OnlyLiteralPrimitiveNumber) => (ReturnType[keyof GenericMatcher], AnyFunction>> | GenericOutput);
+export declare function matchWithNumberOtherwise, GenericMatcher extends ComputeMatcher, GenericOutput>(input: GenericInput & OnlyLiteralPrimitiveNumber, matcher: FixDeepFunctionInfer, GenericMatcher> & ForbiddenMoreKey, otherwise: (value: OtherwiseValue) => GenericOutput): (ReturnType> | GenericOutput);
+export {};
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.mjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.mjs
new file mode 100644
index 000000000..d3ac2defc
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithNumberOtherwise.mjs
@@ -0,0 +1,16 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+
+function execute(input, matcher, otherwise) {
+ const callback = matcher[unwrap(input)];
+ return callback === undefined ? otherwise(input) : callback(input);
+}
+function matchWithNumberOtherwise(...args) {
+ if (args.length === 2) {
+ const [matcher, otherwise] = args;
+ return (input) => execute(input, matcher, otherwise);
+ }
+ const [input, matcher, otherwise] = args;
+ return execute(input, matcher, otherwise);
+}
+
+export { matchWithNumberOtherwise };
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithString.cjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.cjs
new file mode 100644
index 000000000..2d70fa24d
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.cjs
@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../common/unwrap.cjs');
+
+function matchWithString(...args) {
+ if (args.length === 1) {
+ const [matcher] = args;
+ return (input) => matcher[unwrap.unwrap(input)](input);
+ }
+ const [input, matcher] = args;
+ return matcher[unwrap.unwrap(input)](input);
+}
+
+exports.matchWithString = matchWithString;
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithString.d.ts b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.d.ts
new file mode 100644
index 000000000..c72890efd
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.d.ts
@@ -0,0 +1,55 @@
+import { type ComputedTypeError, type FixDeepFunctionInfer, type IsEqual, type Unwrap } from "../../../common";
+import { type Primitive } from "../base";
+import { type OnlyLiteralPrimitiveString } from "../../../clean/types/onlyLiteral";
+type ComputeMatcher> = {
+ [Prop in Unwrap]: (value: GenericInput & Primitive) => unknown;
+};
+type ForbiddenMoreKey, GenericMatcher extends ComputeMatcher> = Exclude> extends infer InferredKey ? IsEqual extends true ? unknown : ComputedTypeError<`Key "${Extract}" is forbidden.`> : never;
+/**
+ * Performs exhaustive pattern matching on the value of a Clean string primitive.
+ *
+ * **Supported call styles:**
+ * - Classic: `matchWithString(input, matcher)` -> runs the handler matching the wrapped value
+ * - Curried: `matchWithString(matcher)` -> returns a function waiting for the primitive
+ *
+ * A Clean primitive cannot be used directly as an object key, so the matcher uses raw string values as keys. Every possible value must have a handler. The selected handler receives the original Clean primitive narrowed to the matching key, preserving its constraints and `NewType` metadata.
+ *
+ * ```ts
+ * const status = C.String.createOrThrow(
+ * "success" as "success" | "failure",
+ * );
+ *
+ * C.matchWithString(status, {
+ * success: () => 200,
+ * failure: () => 500,
+ * }); // 200 | 500
+ *
+ * pipe(
+ * status,
+ * C.matchWithString({
+ * success: (value) => value,
+ * failure: () => status,
+ * }),
+ * ); // C.Primitive<"success" | "failure">
+ *
+ * const noBlankStatus = C.NoBlank.createOrThrow(
+ * "success" as "success" | "failure",
+ * );
+ *
+ * C.matchWithString(noBlankStatus, {
+ * success: (value) => value,
+ * failure: (value) => value,
+ * }); // C.ConstrainedType<"no-blank", "success" | "failure">
+ * ```
+ *
+ * @remarks A broad `Primitive` is supported with a `Record` matcher. Literal unions reject missing and additional keys.
+ *
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithString
+ * @see [`C.matchWithNumber`](https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithNumber)
+ *
+ * @namespace C
+ *
+ */
+export declare function matchWithString, GenericMatcher extends ComputeMatcher>(matcher: FixDeepFunctionInfer>, GenericMatcher> & ForbiddenMoreKey, GenericMatcher>): (input: GenericInput & OnlyLiteralPrimitiveString) => ReturnType[keyof GenericMatcher]>;
+export declare function matchWithString, GenericMatcher extends ComputeMatcher>(input: GenericInput & OnlyLiteralPrimitiveString, matcher: FixDeepFunctionInfer, GenericMatcher> & ForbiddenMoreKey): ReturnType;
+export {};
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithString.mjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.mjs
new file mode 100644
index 000000000..5eaa0841b
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithString.mjs
@@ -0,0 +1,12 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+
+function matchWithString(...args) {
+ if (args.length === 1) {
+ const [matcher] = args;
+ return (input) => matcher[unwrap(input)](input);
+ }
+ const [input, matcher] = args;
+ return matcher[unwrap(input)](input);
+}
+
+export { matchWithString };
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.cjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.cjs
new file mode 100644
index 000000000..615e6fd09
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.cjs
@@ -0,0 +1,18 @@
+'use strict';
+
+var unwrap = require('../../../common/unwrap.cjs');
+
+function execute(input, matcher, otherwise) {
+ const callback = matcher[unwrap.unwrap(input)];
+ return callback === undefined ? otherwise(input) : callback(input);
+}
+function matchWithStringOtherwise(...args) {
+ if (args.length === 2) {
+ const [matcher, otherwise] = args;
+ return (input) => execute(input, matcher, otherwise);
+ }
+ const [input, matcher, otherwise] = args;
+ return execute(input, matcher, otherwise);
+}
+
+exports.matchWithStringOtherwise = matchWithStringOtherwise;
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.d.ts b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.d.ts
new file mode 100644
index 000000000..355adaa11
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.d.ts
@@ -0,0 +1,61 @@
+import { type AnyFunction, type ComputedTypeError, type FixDeepFunctionInfer, type IsEqual, type Unwrap } from "../../../common";
+import { type GetPropsWithValueExtends } from "../../../object";
+import { type OnlyLiteralPrimitiveString } from "../../../clean/types/onlyLiteral";
+import { type Primitive } from "../base";
+type ComputeMatcher> = {
+ [Prop in Unwrap]?: (value: GenericInput & Primitive) => unknown;
+};
+type ForbiddenMoreKey, GenericMatcher extends ComputeMatcher> = Exclude> extends infer InferredKey ? IsEqual extends true ? unknown : ComputedTypeError<`Key "${Extract}" is forbidden.`> : never;
+type HandledKeys = Extract, string>;
+type OtherwiseValue, GenericMatcher extends object> = Extract, HandledKeys>>, any>;
+/** Performs partial pattern matching on a Clean string primitive and delegates unhandled values to an `otherwise` callback.
+/**
+/** **Supported call styles:**
+/** - Classic: `matchWithStringOtherwise(input, matcher, otherwise)` -> runs a matching handler or the fallback
+/** - Curried: `matchWithStringOtherwise(matcher, otherwise)` -> returns a function waiting for the primitive
+/**
+/** Raw string values are used as matcher keys. Handlers receive the original primitive narrowed to their key, and `otherwise` receives the same original primitive narrowed to all remaining values.
+/**
+/** ```ts
+/** const status = C.String.createOrThrow(
+/** "success" as "success" | "failure" | "pending",
+/** );
+/**
+/** C.matchWithStringOtherwise(
+/** status,
+/** {
+/** success: () => 200,
+/** },
+/** () => 500,
+/** ); // number
+/**
+/** pipe(
+/** status,
+/** C.matchWithStringOtherwise(
+/** {
+/** failure: () => "retry",
+/** },
+/** (value) => value,
+/** ),
+/** ); // "retry" | C.Primitive<"success" | "pending">
+/**
+/** const result = C.matchWithStringOtherwise(
+/** status,
+/** {
+/** success: (value) => value,
+/** failure: undefined,
+/** },
+/** (value) => value,
+/** ); // C.Primitive<"success" | "failure" | "pending">
+/** ```
+/**
+/** @remarks Constraints and `NewType` metadata remain attached to the primitive passed to every callback.
+/**
+/** @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithStringOtherwise
+/** @see [`C.matchWithString`](https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/matchWithString)
+/**
+/** @namespace C
+/** */
+export declare function matchWithStringOtherwise, GenericMatcher extends ComputeMatcher, GenericOutput>(matcher: FixDeepFunctionInfer>, GenericMatcher> & ForbiddenMoreKey, GenericMatcher>, otherwise: (value: OtherwiseValue) => GenericOutput): (input: GenericInput & OnlyLiteralPrimitiveString) => (ReturnType[keyof GenericMatcher], AnyFunction>> | GenericOutput);
+export declare function matchWithStringOtherwise, GenericMatcher extends ComputeMatcher, GenericOutput>(input: GenericInput & OnlyLiteralPrimitiveString, matcher: FixDeepFunctionInfer, GenericMatcher> & ForbiddenMoreKey, otherwise: (value: OtherwiseValue) => GenericOutput): (ReturnType> | GenericOutput);
+export {};
diff --git a/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.mjs b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.mjs
new file mode 100644
index 000000000..e7fa46ba9
--- /dev/null
+++ b/docs/public/libs/v1/clean/primitive/matcher/matchWithStringOtherwise.mjs
@@ -0,0 +1,16 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+
+function execute(input, matcher, otherwise) {
+ const callback = matcher[unwrap(input)];
+ return callback === undefined ? otherwise(input) : callback(input);
+}
+function matchWithStringOtherwise(...args) {
+ if (args.length === 2) {
+ const [matcher, otherwise] = args;
+ return (input) => execute(input, matcher, otherwise);
+ }
+ const [input, matcher, otherwise] = args;
+ return execute(input, matcher, otherwise);
+}
+
+export { matchWithStringOtherwise };
diff --git a/docs/public/libs/v1/clean/types/onlyLiteral.d.ts b/docs/public/libs/v1/clean/types/onlyLiteral.d.ts
new file mode 100644
index 000000000..691825e75
--- /dev/null
+++ b/docs/public/libs/v1/clean/types/onlyLiteral.d.ts
@@ -0,0 +1,7 @@
+import { type Unwrap, type ComputedTypeError } from "../../common";
+import { type Primitive } from "../primitive";
+export type OnlyLiteralPrimitiveString = string extends Unwrap ? ComputedTypeError<"Input primitive must be a literal string."> : GenericValue;
+export type OnlyLiteralPrimitiveNumber = number extends Unwrap ? ComputedTypeError<"Input primitive must be a literal number."> : GenericValue;
+export type OnlyLiteralPrimitiveBigInt = bigint extends Unwrap ? ComputedTypeError<"Input primitive must be a literal bigint."> : GenericValue;
+export type OnlyLiteralPrimitiveBoolean = boolean extends Unwrap ? ComputedTypeError<"Input primitive must be a literal boolean."> : GenericValue;
+export type OnlyLiteral = (OnlyLiteralPrimitiveString & OnlyLiteralPrimitiveNumber & OnlyLiteralPrimitiveBigInt & OnlyLiteralPrimitiveBoolean);
diff --git a/docs/public/libs/v1/common/index.cjs b/docs/public/libs/v1/common/index.cjs
index c93590b81..02080fb3b 100644
--- a/docs/public/libs/v1/common/index.cjs
+++ b/docs/public/libs/v1/common/index.cjs
@@ -62,6 +62,8 @@ var kindClass = require('./kindClass.cjs');
var promiseAll = require('./promiseAll.cjs');
var detachObjectMethod = require('./detachObjectMethod.cjs');
var bindPrototypeMethods = require('./bindPrototypeMethods.cjs');
+var preparePipe = require('./preparePipe.cjs');
+var prepareAsyncPipe = require('./prepareAsyncPipe.cjs');
/**
* {@include common/index.md}
@@ -154,3 +156,5 @@ exports.kindClass = kindClass.kindClass;
exports.promiseAll = promiseAll.promiseAll;
exports.detachObjectMethod = detachObjectMethod.detachObjectMethod;
exports.bindPrototypeMethods = bindPrototypeMethods.bindPrototypeMethods;
+exports.preparePipe = preparePipe.preparePipe;
+exports.prepareAsyncPipe = prepareAsyncPipe.prepareAsyncPipe;
diff --git a/docs/public/libs/v1/common/index.d.ts b/docs/public/libs/v1/common/index.d.ts
index c483a2e03..ac15d986a 100644
--- a/docs/public/libs/v1/common/index.d.ts
+++ b/docs/public/libs/v1/common/index.d.ts
@@ -86,3 +86,5 @@ export * from "./kindClass";
export * from "./promiseAll";
export * from "./detachObjectMethod";
export * from "./bindPrototypeMethods";
+export * from "./preparePipe";
+export * from "./prepareAsyncPipe";
diff --git a/docs/public/libs/v1/common/index.mjs b/docs/public/libs/v1/common/index.mjs
index f8f7f133f..917af8810 100644
--- a/docs/public/libs/v1/common/index.mjs
+++ b/docs/public/libs/v1/common/index.mjs
@@ -60,6 +60,8 @@ export { kindClass } from './kindClass.mjs';
export { promiseAll } from './promiseAll.mjs';
export { detachObjectMethod } from './detachObjectMethod.mjs';
export { bindPrototypeMethods } from './bindPrototypeMethods.mjs';
+export { preparePipe } from './preparePipe.mjs';
+export { prepareAsyncPipe } from './prepareAsyncPipe.mjs';
/**
* {@include common/index.md}
diff --git a/docs/public/libs/v1/common/prepareAsyncPipe.cjs b/docs/public/libs/v1/common/prepareAsyncPipe.cjs
new file mode 100644
index 000000000..fcdecbd71
--- /dev/null
+++ b/docs/public/libs/v1/common/prepareAsyncPipe.cjs
@@ -0,0 +1,14 @@
+'use strict';
+
+/** {@include common/prepareAsyncPipe/index.md} */
+function prepareAsyncPipe() {
+ return (...pipes) => async (input) => {
+ let acc = await input;
+ for (const pipe of pipes) {
+ acc = await pipe(acc);
+ }
+ return acc;
+ };
+}
+
+exports.prepareAsyncPipe = prepareAsyncPipe;
diff --git a/docs/public/libs/v1/common/prepareAsyncPipe.d.ts b/docs/public/libs/v1/common/prepareAsyncPipe.d.ts
new file mode 100644
index 000000000..f15c9fe6d
--- /dev/null
+++ b/docs/public/libs/v1/common/prepareAsyncPipe.d.ts
@@ -0,0 +1,60 @@
+import { type BreakGenericLink, type MaybePromise } from "./types";
+export interface PrepareAsyncPipe {
+ (pipe1: (input: BreakGenericLink) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise, pipe5: (input: GenericOutputPipe4) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise, pipe5: (input: GenericOutputPipe4) => MaybePromise, pipe6: (input: GenericOutputPipe5) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise, pipe5: (input: GenericOutputPipe4) => MaybePromise, pipe6: (input: GenericOutputPipe5) => MaybePromise, pipe7: (input: GenericOutputPipe6) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise, pipe5: (input: GenericOutputPipe4) => MaybePromise, pipe6: (input: GenericOutputPipe5) => MaybePromise, pipe7: (input: GenericOutputPipe6) => MaybePromise, pipe8: (input: GenericOutputPipe7) => MaybePromise): (input: MaybePromise) => Promise;
+ (pipe1: (input: BreakGenericLink) => MaybePromise, pipe2: (input: GenericOutputPipe1) => MaybePromise, pipe3: (input: GenericOutputPipe2) => MaybePromise, pipe4: (input: GenericOutputPipe3) => MaybePromise, pipe5: (input: GenericOutputPipe4) => MaybePromise