@duplojs/utils 1.4.32 → 1.4.34

package/dist/array/select.d.ts

@@ -13,6 +13,45 @@ interface ArraySelectParams<GenericInputArray extends readonly unknown[]> {
     select<GenericOutput extends AnyValue = AnyValue>(output: GenericOutput): ArraySelectSelect<GenericOutput>;
 }
 export declare const selectTools: Pick<ArraySelectParams<any>, "skip" | "select">;
+/**
+ * Builds a new array by selecting or skipping elements.
+ * 
+ * **Supported call styles:**
+ * - Classic: `select(array, theFunction)` → returns a new array
+ * - Curried: `select(theFunction)` → returns a function waiting for the array
+ * 
+ * The function receives `{ element, index, self, select, skip }`.
+ * Use `select(value)` to keep a value or `skip()` to ignore it.
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.select(
+ * 	[1, 2, 3],
+ * 	({ element, select }) => select(element * 2),
+ * ); // [2, 4, 6]
+ * 
+ * A.select(
+ * 	[1, 2, 3],
+ * 	({ element, skip, select }) => element > 1 ? select(element) : skip(),
+ * ); // [2, 3]
+ * 
+ * pipe(
+ * 	["alpha", "beta"],
+ * 	A.select(({ index, select }) => select(index)),
+ * ); // [0, 1]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - This is similar to a combined `map` + `filter`
+ * 
+ * @see [`A.map`](https://utils.duplojs.dev/en/v1/api/array/map) For mapping elements
+ * @see [`A.filter`](https://utils.duplojs.dev/en/v1/api/array/filter) For filtering elements
+ * @see https://utils.duplojs.dev/en/v1/api/array/select
+ * 
+ * @namespace A
+ * 
+ */
 export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): (input: GenericInput) => GenericSelect["-select"][];
 export declare function select<GenericInput extends readonly unknown[], GenericSelect extends ArraySelectSelect>(input: GenericInput, theFunction: (params: ArraySelectParams<GenericInput>) => GenericSelect | ArraySelectSkip): GenericSelect["-select"][];
 export {};

package/dist/array/set.d.ts

@@ -1,2 +1,41 @@
+/**
+ * Sets an element at a given index.
+ * 
+ * **Supported call styles:**
+ * - Classic: `set(array, index, value)` → returns a new array
+ * - Curried: `set(index, value)` → returns a function waiting for the array
+ * 
+ * Negative indices are supported.
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.set(
+ * 	[1, 2, 3],
+ * 	1,
+ * 	9,
+ * ); // [1, 9, 3]
+ * 
+ * A.set(
+ * 	[1, 2, 3],
+ * 	-1,
+ * 	0,
+ * ); // [1, 2, 0]
+ * 
+ * pipe(
+ * 	["alpha", "beta"],
+ * 	A.set(0, "gamma"),
+ * ); // ["gamma", "beta"]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.with`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/with) for index normalization
+ * 
+ * @see [`A.at`](https://utils.duplojs.dev/en/v1/api/array/at) For reading an index
+ * @see https://utils.duplojs.dev/en/v1/api/array/set
+ * 
+ * @namespace A
+ * 
+ */
 export declare function set<GenericValue extends unknown>(index: number, value: GenericValue): (array: readonly GenericValue[]) => GenericValue[];
 export declare function set<GenericValue extends unknown>(array: readonly GenericValue[], index: number, value: GenericValue): GenericValue[];

package/dist/array/shift.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include array/shift/index.md}
+ */
 function shift(array) {
     return array.slice(1);
 }

package/dist/array/shift.d.ts

@@ -1,3 +1,34 @@
 import { type AnyTuple } from "../common";
 import { type ShiftTuple } from "../array/types/shiftTuple";
+/**
+ * Removes the first element from an array.
+ * 
+ * Signature: `shift(array)` → returns a new array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.shift(
+ * 	[1, 2, 3],
+ * ); // [2, 3]
+ * 
+ * A.shift(
+ * 	<const>["alpha", "beta"],
+ * ); // ["beta"]
+ * 
+ * A.shift(
+ * 	[],
+ * ); // []
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Type-safe with tuple types: return type is inferred without the first element
+ * 
+ * @see [`A.pop`](https://utils.duplojs.dev/en/v1/api/array/pop) For removing the last element
+ * @see https://utils.duplojs.dev/en/v1/api/array/shift
+ * 
+ * @namespace A
+ * 
+ */
 export declare function shift<const GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? ShiftTuple<GenericArray> : GenericArray;

package/dist/array/shift.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include array/shift/index.md}
+ */
 function shift(array) {
     return array.slice(1);
 }

package/dist/array/slice.d.ts

@@ -1,2 +1,38 @@
+/**
+ * Slices a portion of an array.
+ * 
+ * **Supported call styles:**
+ * - Classic: `slice(array, start?, end?)` → returns a new array
+ * - Curried: `slice(start?, end?)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.slice(
+ * 	[1, 2, 3, 4],
+ * 	1,
+ * 	3,
+ * ); // [2, 3]
+ * 
+ * pipe(
+ * 	["alpha", "beta", "gamma"],
+ * 	A.slice(1),
+ * ); // ["beta", "gamma"]
+ * 
+ * A.slice(
+ * 	[1, 2, 3],
+ * 	-2,
+ * ); // [2, 3]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/array/slice
+ * 
+ * @namespace A
+ * 
+ */
 export declare function slice<GenericElement extends unknown>(start?: number, end?: number): (array: readonly GenericElement[]) => GenericElement[];
 export declare function slice<GenericElement extends unknown>(array: readonly GenericElement[], start?: number, end?: number): GenericElement[];

package/dist/array/some.d.ts

@@ -2,6 +2,50 @@ interface ArraySomeParams<GenericInputArray extends readonly unknown[]> {
     index: number;
     self: GenericInputArray;
 }
+/**
+ * Checks whether at least one element satisfies a predicate.
+ * 
+ * **Supported call styles:**
+ * - Classic: `some(array, predicate)` → returns a boolean
+ * - Curried: `some(predicate)` → returns a function waiting for the array
+ * 
+ * The predicate receives `(element, { index, self })`, where `index` is the element position
+ * and `self` is the original array.
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.some(
+ * 	[1, 2, 3],
+ * 	(value) => value > 2,
+ * ); // true
+ * 
+ * A.some(
+ * 	["alpha", "beta"],
+ * 	(value) => value === "gamma",
+ * ); // false
+ * 
+ * pipe(
+ * 	[1, 2, 3],
+ * 	when(
+ * 		A.some((value) => value > 2),
+ * 		(items) => {
+ * 			// items has at least one match
+ * 		},
+ * 	),
+ * );
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.some`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
+ * 
+ * @see [`A.every`](https://utils.duplojs.dev/en/v1/api/array/every) For checking all elements
+ * @see [`A.filter`](https://utils.duplojs.dev/en/v1/api/array/filter) For selecting matches
+ * @see https://utils.duplojs.dev/en/v1/api/array/some
+ * 
+ * @namespace A
+ * 
+ */
 export declare function some<GenericInput extends readonly unknown[]>(predicate: (element: GenericInput[number], params: ArraySomeParams<GenericInput>) => boolean): (input: GenericInput) => boolean;
 export declare function some<GenericInput extends readonly unknown[]>(input: GenericInput, predicate: (element: GenericInput[number], params: ArraySomeParams<GenericInput>) => boolean): boolean;
 export {};

package/dist/array/sort.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Sorts an array using a compare function.
+ * 
+ * **Supported call styles:**
+ * - Classic: `sort(array, compareFn)` → returns a new array
+ * - Curried: `sort(compareFn)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.sort(
+ * 	[3, 1, 2],
+ * 	(first, second) => first - second,
+ * ); // [1, 2, 3]
+ * 
+ * pipe(
+ * 	["beta", "alpha"],
+ * 	A.sort((first, second) => first.localeCompare(second)),
+ * ); // ["alpha", "beta"]
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/array/sort
+ * 
+ * @namespace A
+ * 
+ */
 export declare function sort<GenericElement extends unknown>(compareFn: (first: GenericElement, second: GenericElement) => number): (array: readonly GenericElement[]) => GenericElement[];
 export declare function sort<GenericElement extends unknown>(array: readonly GenericElement[], compareFn: (first: GenericElement, second: GenericElement) => number): GenericElement[];

package/dist/array/splice/delete.d.ts

@@ -1,2 +1,34 @@
+/**
+ * Deletes a segment from an array using splice semantics.
+ * 
+ * **Supported call styles:**
+ * - Classic: `spliceDelete(array, indexTo, deleteCount)` → returns a new array
+ * - Curried: `spliceDelete(indexTo, deleteCount)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.spliceDelete(
+ * 	[1, 2, 3, 4],
+ * 	1,
+ * 	2,
+ * ); // [1, 4]
+ * 
+ * pipe(
+ * 	["alpha", "beta", "gamma"],
+ * 	A.spliceDelete(0, 1),
+ * ); // ["beta", "gamma"]
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+ * 
+ * @see [`A.spliceInsert`](https://utils.duplojs.dev/en/v1/api/array/spliceInsert) For inserting values
+ * @see [`A.spliceReplace`](https://utils.duplojs.dev/en/v1/api/array/spliceReplace) For replacing values
+ * @see https://utils.duplojs.dev/en/v1/api/array/spliceDelete
+ * 
+ * @namespace A
+ * 
+ */
 export declare function spliceDelete<GenericElement extends unknown>(indexTo: number, deleteCount: number): (array: readonly GenericElement[]) => GenericElement[];
 export declare function spliceDelete<GenericElement extends unknown>(array: readonly GenericElement[], indexTo: number, deleteCount: number): GenericElement[];

package/dist/array/splice/insert.d.ts

@@ -1,2 +1,41 @@
+/**
+ * Inserts elements into an array using splice semantics.
+ * 
+ * **Supported call styles:**
+ * - Classic: `spliceInsert(array, indexFrom, elements)` → returns a new array
+ * - Curried: `spliceInsert(indexFrom, elements)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.spliceInsert(
+ * 	[1, 2, 3],
+ * 	1,
+ * 	[9],
+ * ); // [1, 9, 2, 3]
+ * 
+ * pipe(
+ * 	["alpha", "beta"],
+ * 	A.spliceInsert(0, ["start"]),
+ * ); // ["start", "alpha", "beta"]
+ * 
+ * A.spliceInsert(
+ * 	[1, 2],
+ * 	2,
+ * 	[3],
+ * ); // [1, 2, 3]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+ * 
+ * @see [`A.spliceDelete`](https://utils.duplojs.dev/en/v1/api/array/spliceDelete) For deleting values
+ * @see [`A.spliceReplace`](https://utils.duplojs.dev/en/v1/api/array/spliceReplace) For replacing values
+ * @see https://utils.duplojs.dev/en/v1/api/array/spliceInsert
+ * 
+ * @namespace A
+ * 
+ */
 export declare function spliceInsert<GenericElement extends unknown>(indexFrom: number, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
 export declare function spliceInsert<GenericElement extends unknown>(array: readonly GenericElement[], indexFrom: number, elements: GenericElement[]): GenericElement[];

package/dist/array/splice/replace.d.ts

@@ -1,2 +1,41 @@
+/**
+ * Replaces a segment using splice semantics.
+ * 
+ * **Supported call styles:**
+ * - Classic: `spliceReplace(array, indexFrom, elements)` → returns a new array
+ * - Curried: `spliceReplace(indexFrom, elements)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.spliceReplace(
+ * 	[1, 2, 3],
+ * 	1,
+ * 	[9, 8],
+ * ); // [1, 9, 8]
+ * 
+ * pipe(
+ * 	["alpha", "beta", "gamma"],
+ * 	A.spliceReplace(1, ["delta"]),
+ * ); // ["alpha", "delta", "gamma"]
+ * 
+ * A.spliceReplace(
+ * 	[1, 2],
+ * 	0,
+ * 	[3],
+ * ); // [3, 2]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Array.prototype.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+ * 
+ * @see [`A.spliceDelete`](https://utils.duplojs.dev/en/v1/api/array/spliceDelete) For deleting values
+ * @see [`A.spliceInsert`](https://utils.duplojs.dev/en/v1/api/array/spliceInsert) For inserting values
+ * @see https://utils.duplojs.dev/en/v1/api/array/spliceReplace
+ * 
+ * @namespace A
+ * 
+ */
 export declare function spliceReplace<GenericElement extends unknown>(indexFrom: number, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
 export declare function spliceReplace<GenericElement extends unknown>(array: readonly GenericElement[], indexFrom: number, elements: GenericElement[]): GenericElement[];

package/dist/array/sum.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include array/sum/index.md}
+ */
 function sum(array) {
     let result = 0;
     for (const number of array) {

package/dist/array/sum.d.ts

@@ -1 +1,23 @@
+/**
+ * Sums all numbers in an array.
+ * 
+ * Signature: `sum(array)` → returns the total
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.sum([1, 2, 3]); // 6
+ * 
+ * A.sum([10, -5, 1]); // 6
+ * 
+ * A.sum([]); // 0
+ * ```
+ * 
+ * @see [`A.minOf`](https://utils.duplojs.dev/en/v1/api/array/minOf) For the minimum value
+ * @see [`A.maxOf`](https://utils.duplojs.dev/en/v1/api/array/maxOf) For the maximum value
+ * @see https://utils.duplojs.dev/en/v1/api/array/sum
+ * 
+ * @namespace A
+ * 
+ */
 export declare function sum<GenericArray extends readonly number[]>(array: GenericArray): number;

package/dist/array/sum.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include array/sum/index.md}
+ */
 function sum(array) {
     let result = 0;
     for (const number of array) {

package/dist/array/toTuple.d.ts

@@ -7,6 +7,39 @@ type ComputesResult<GenericShapeTuple extends ShapeTuple<any>> = GenericShapeTup
     infer InferredFirst extends AnyFunction,
     ...infer InferredRest extends ShapeTuple<any> | readonly []
 ] ? InferredRest extends ShapeTuple<any> ? ComputesResult<InferredRest> extends infer inferredResult extends readonly any[] ? [ReturnType<InferredFirst>, ...inferredResult] : never : [ReturnType<InferredFirst>] : never;
+/**
+ * Transforms a value into a tuple using a shape of functions.
+ * 
+ * **Supported call styles:**
+ * - Classic: `toTuple(input, shape)` → returns a tuple of results
+ * - Curried: `toTuple(shape)` → returns a function waiting for the input
+ * 
+ * Each function in the shape receives the same input.
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * A.toTuple(
+ * 	2,
+ * 	[
+ * 		(value) => value + 1,
+ * 		(value) => value * 2,
+ * 	],
+ * ); // [3, 4]
+ * 
+ * pipe(
+ * 	"alpha",
+ * 	A.toTuple(
+ * 		[(value) => value.length],
+ * 	),
+ * ); // [5]
+ * ```
+ * 
+ * @see [`A.map`](https://utils.duplojs.dev/en/v1/api/array/map) For mapping arrays
+ * @see https://utils.duplojs.dev/en/v1/api/array/toTuple
+ * 
+ * @namespace A
+ * 
+ */
 export declare function toTuple<GenericInput extends unknown, GenericShapeTuple extends ShapeTuple<NoInfer<GenericInput>>>(shapeObject: ShapeTuple<NoInfer<GenericInput>> & GenericShapeTuple): (input: GenericInput) => ComputesResult<NoInfer<GenericShapeTuple>>;
 export declare function toTuple<GenericInput extends unknown, GenericShapeTuple extends ShapeTuple<GenericInput>>(input: GenericInput, shapeObject: FixDeepFunctionInfer<ShapeTuple<GenericInput>, GenericShapeTuple>): ComputesResult<GenericShapeTuple>;
 export {};

package/dist/array/unshift.d.ts

@@ -1,2 +1,40 @@
+/**
+ * Adds elements to the start of an array.
+ * 
+ * **Supported call styles:**
+ * - Classic: `unshift(array, element, ...elements)` → returns a new array
+ * - Curried: `unshift(element)` → returns a function waiting for the array
+ * 
+ * The input array is not mutated.
+ * 
+ * ```ts
+ * A.unshift(
+ * 	[2, 3],
+ * 	1,
+ * ); // [1, 2, 3]
+ * 
+ * A.unshift(
+ * 	[3, 4],
+ * 	1,
+ * 	2,
+ * ); // [1, 2, 3, 4]
+ * 
+ * pipe(
+ * 	["beta", "gamma"],
+ * 	A.unshift("alpha"),
+ * ); // ["alpha", "beta", "gamma"]
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Classic style supports multiple elements via rest parameters
+ * - Curried style adds only a single element
+ * 
+ * @see [`A.push`](https://utils.duplojs.dev/en/v1/api/array/push) For adding at the end
+ * @see https://utils.duplojs.dev/en/v1/api/array/unshift
+ * 
+ * @namespace A
+ * 
+ */
 export declare function unshift<GenericElement extends unknown>(element: NoInfer<GenericElement>): (array: readonly GenericElement[]) => GenericElement[];
 export declare function unshift<GenericElement extends unknown>(array: readonly GenericElement[], element: NoInfer<GenericElement>, ...elements: NoInfer<GenericElement>[]): GenericElement[];

package/dist/clean/constraint/base.cjs

@@ -23,6 +23,9 @@ class CreateConstrainedTypeError extends kind$1.kindHeritage("create-constrained
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createConstraint/index.md}
+ */
 function createConstraint(name, primitiveHandler, checker) {
     const checkers = coalescing.coalescing(checker);
     const dataParserWithCheckers = primitiveHandler

package/dist/clean/constraint/base.d.ts

@@ -8,15 +8,73 @@ export interface ConstrainedType<GenericName extends string, GenericValue extend
 }
 export declare const constraintHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraint-handler", unknown>>;
 export interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DDataParser.DataParserChecker[] = readonly DDataParser.DataParserChecker[]> extends Kind<typeof constraintHandlerKind.definition> {
+    /**
+     * The constraint name used as the internal marker (for example "email").
+     * 
+     */
     readonly name: GenericName;
+    /**
+     * The list of DataParser checkers used to validate the primitive.
+     * 
+     */
     readonly checkers: GenericCheckers;
+    /**
+     * The primitive handler on which the constraint applies (String, Number, etc.).
+     * 
+     */
     readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+    /**
+     * Creates a constrained value and returns an Either.
+     * 
+     * ```ts
+     * const result = Between1And10.create(5);
+     * 
+     * if (E.isRight(result)) {
+     * 	// result : E.EitherRight<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
+     * }
+     * ```
+     * 
+     */
     create<GenericData extends GenericPrimitiveValue>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericData>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
     create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.EitherRight<"createConstrainedType", (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>)> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value and throws on error.
+     * 
+     * ```ts
+     * const value = Between1And10.createOrThrow(7);
+     * // value: C.ConstrainedType<"between-1-10", 7>
+     * ```
+     * 
+     */
     createOrThrow<GenericData extends GenericPrimitiveValue>(data: GenericData): ConstrainedType<GenericName, GenericData>;
     createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>);
+    /**
+     * Creates a constrained value from an unknown input and returns an Either.
+     * 
+     * ```ts
+     * const unknownValue: unknown = 9;
+     * const maybe = Between1And10.createWithUnknown(unknownValue);
+     * ```
+     * 
+     */
     createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createConstrainedType", ConstrainedType<GenericName, GenericPrimitiveValue>> | DEither.EitherLeft<"createConstrainedTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value from an unknown input and throws on error.
+     * 
+     * ```ts
+     * const strictValue = Between1And10.createWithUnknownOrThrow(unknownValue);
+     * ```
+     * 
+     */
     createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): ConstrainedType<GenericName, GenericPrimitiveValue>;
+    /**
+     * Checks if a value carries this constraint (type guard).
+     * 
+     * ```ts
+     * Between1And10.is(value); // type guard
+     * ```
+     * 
+     */
     is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, ConstrainedType<GenericName, GenericPrimitiveValue>>;
 }
 declare const CreateConstrainedTypeError_base: new (params: {
@@ -28,6 +86,54 @@ export declare class CreateConstrainedTypeError extends CreateConstrainedTypeErr
     dataParserError: DDataParser.DataParserError;
     constructor(constrainedTypeName: string, data: unknown, dataParserError: DDataParser.DataParserError);
 }
+/**
+ * Creates a constraint handler to enforce a rule on a primitive.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createConstraint(name, primitive, checker)` -> returns a handler
+ * 
+ * Constraints cover rules that typing cannot express (format, range, custom checks). The handler validates input, tags the value with the constraint name, and can be reused as a contract or plugged into a NewType.
+ * 
+ * ```ts
+ * const Between1And10 = C.createConstraint(
+ * 	"between-1-10",
+ * 	C.Number,
+ * 	[
+ * 		DP.checkerNumberMin(1),
+ * 		DP.checkerNumberMax(10),
+ * 	],
+ * );
+ * 
+ * const result = Between1And10.create(5);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result : E.EitherRight<"createConstrainedType", C.ConstrainedType<"between-1-10", 5>>
+ * }
+ * 
+ * const value = Between1And10.createOrThrow(7);
+ * // value: C.ConstrainedType<"between-1-10", 7>
+ * 
+ * const primitive = C.Number.createOrThrow(3);
+ * Between1And10.create(primitive);
+ * 
+ * Between1And10.is(value); // type guard
+ * 
+ * const unknownValue: unknown = 9;
+ * const maybe = Between1And10.createWithUnknown(unknownValue);
+ * 
+ * const strictValue = Between1And10.createWithUnknownOrThrow(unknownValue);
+ * 
+ * ```
+ * 
+ * @remarks
+ * - You can pass multiple DataParser checkers by providing an array.
+ * - The handler accepts both raw values and primitive values.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createConstraint<GenericName extends string, GenericPrimitiveValue extends EligiblePrimitive, const GenericChecker extends (DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue> | readonly [
     DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
     ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]

package/dist/clean/constraint/base.mjs

@@ -21,6 +21,9 @@ class CreateConstrainedTypeError extends kindHeritage("create-constrained-type-e
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createConstraint/index.md}
+ */
 function createConstraint(name, primitiveHandler, checker) {
     const checkers = coalescing(checker);
     const dataParserWithCheckers = primitiveHandler

package/dist/clean/constraint/defaultConstraint/number.cjs

@@ -6,8 +6,17 @@ var int = require('../../../dataParser/parsers/number/checkers/int.cjs');
 var min = require('../../../dataParser/parsers/number/checkers/min.cjs');
 var max = require('../../../dataParser/parsers/number/checkers/max.cjs');
 
+/**
+ * {@include clean/Int/index.md}
+ */
 const Int = base.createConstraint("int", base$1.Number, int.checkerInt());
+/**
+ * {@include clean/Positive/index.md}
+ */
 const Positive = base.createConstraint("positive", base$1.Number, min.checkerNumberMin(1));
+/**
+ * {@include clean/Negative/index.md}
+ */
 const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(-1));
 
 exports.Int = Int;