@duplojs/utils 1.4.32 → 1.4.33

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -1,8 +1,89 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+/**
+ * Constraint handler that validates integer numbers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `Int.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes to integers.
+ * 
+ * ```ts
+ * const result = C.Int.create(12);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"int", 12>>
+ * }
+ * 
+ * const value = C.Int.createOrThrow(7);
+ * // value: C.ConstrainedType<"int", 7>
+ * 
+ * C.Int.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt]>;
 export type Int = GetConstraint<typeof Int>;
+/**
+ * Constraint handler that validates strictly positive numbers (>= 1).
+ * 
+ * **Supported call styles:**
+ * - Classic: `Positive.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes to positive numbers.
+ * 
+ * ```ts
+ * const result = C.Positive.create(4);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"positive", 4>>
+ * }
+ * 
+ * const value = C.Positive.createOrThrow(10);
+ * // value: C.ConstrainedType<"positive", 10>
+ * 
+ * C.Positive.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin]>;
 export type Positive = GetConstraint<typeof Positive>;
+/**
+ * Constraint handler that validates strictly negative numbers (<= -1).
+ * 
+ * **Supported call styles:**
+ * - Classic: `Negative.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes to negative numbers.
+ * 
+ * ```ts
+ * const result = C.Negative.create(-4);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"negative", -4>>
+ * }
+ * 
+ * const value = C.Negative.createOrThrow(-10);
+ * // value: C.ConstrainedType<"negative", -10>
+ * 
+ * C.Negative.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
 export type Negative = GetConstraint<typeof Negative>;

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

@@ -4,8 +4,17 @@ import { checkerInt } from '../../../dataParser/parsers/number/checkers/int.mjs'
 import { checkerNumberMin } from '../../../dataParser/parsers/number/checkers/min.mjs';
 import { checkerNumberMax } from '../../../dataParser/parsers/number/checkers/max.mjs';
 
+/**
+ * {@include clean/Int/index.md}
+ */
 const Int = createConstraint("int", Number, checkerInt());
+/**
+ * {@include clean/Positive/index.md}
+ */
 const Positive = createConstraint("positive", Number, checkerNumberMin(1));
+/**
+ * {@include clean/Negative/index.md}
+ */
 const Negative = createConstraint("negative", Number, checkerNumberMax(-1));
 
 export { Int, Negative, Positive };

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

@@ -5,7 +5,13 @@ var base$1 = require('../../primitive/base.cjs');
 var email = require('../../../dataParser/parsers/string/checkers/email.cjs');
 var url = require('../../../dataParser/parsers/string/checkers/url.cjs');
 
+/**
+ * {@include clean/Email/index.md}
+ */
 const Email = base.createConstraint("email", base$1.String, email.checkerEmail());
+/**
+ * {@include clean/Url/index.md}
+ */
 const Url = base.createConstraint("url", base$1.String, url.checkerUrl());
 
 exports.Email = Email;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -1,6 +1,60 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+/**
+ * Constraint handler that validates an email string.
+ * 
+ * **Supported call styles:**
+ * - Classic: `Email.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes with an email format.
+ * 
+ * ```ts
+ * const result = C.Email.create("hello@duplojs.dev");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"email", "hello@duplojs.dev">>
+ * }
+ * 
+ * const email = C.Email.createOrThrow("a@b.com");
+ * // email: C.ConstrainedType<"email", "a@b.com">
+ * 
+ * C.Email.is(email); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail]>;
 export type Email = GetConstraint<typeof Email>;
+/**
+ * Constraint handler that validates a URL string.
+ * 
+ * **Supported call styles:**
+ * - Classic: `Url.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes with a URL format.
+ * 
+ * ```ts
+ * const result = C.Url.create("https://duplojs.dev");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createConstrainedType", C.ConstrainedType<"url", "https://duplojs.dev">>
+ * }
+ * 
+ * const url = C.Url.createOrThrow("https://example.com");
+ * // url: C.ConstrainedType<"url", "https://example.com">
+ * 
+ * C.Url.is(url); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
 export type Url = GetConstraint<typeof Url>;

package/dist/clean/constraint/defaultConstraint/string.mjs

@@ -3,7 +3,13 @@ import { String } from '../../primitive/base.mjs';
 import { checkerEmail } from '../../../dataParser/parsers/string/checkers/email.mjs';
 import { checkerUrl } from '../../../dataParser/parsers/string/checkers/url.mjs';
 
+/**
+ * {@include clean/Email/index.md}
+ */
 const Email = createConstraint("email", String, checkerEmail());
+/**
+ * {@include clean/Url/index.md}
+ */
 const Url = createConstraint("url", String, checkerUrl());
 
 export { Email, Url };

package/dist/clean/entity.cjs

@@ -48,6 +48,9 @@ class CreateEntityError extends kind$1.kindHeritage("create-entity-error", error
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createEntity/index.md}
+ */
 function createEntity(name, getPropertiesDefinition) {
     function theNew(properties) {
         return entityKind.addTo(properties, name);

package/dist/clean/entity.d.ts

@@ -37,12 +37,80 @@ export interface Entity<GenericName extends string = string> extends Kind<typeof
 }
 declare const entityHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/entity-handler", unknown>>;
 export interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> extends Kind<typeof entityHandlerKind.definition> {
+    /**
+     * The entity name used as a runtime identifier (for example "User").
+     * 
+     */
     readonly name: GenericName;
+    /**
+     * The properties schema returned by the definition callback.
+     * 
+     */
     readonly propertiesDefinition: GenericPropertiesDefinition;
+    /**
+     * The DataParser derived from the properties definition. Useful to reuse validation outside entity creation.
+     * 
+     */
     readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, EntityRawProperties<GenericPropertiesDefinition>>;
+    /**
+     * Builds an entity from already typed properties.
+     * 
+     * ```ts
+     * 	export function create(params: {
+     * 		id: Id;
+     * 		name: Name;
+     * 	}) {
+     * 		return Entity.new({
+     * 			...params,
+     * 			nick: null,
+     * 			roles: [defaultRole],
+     * 		});
+     * ```
+     * 
+     */
     "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
+    /**
+     * Validates raw properties and returns an Either with the typed entity.
+     * 
+     * ```ts
+     * if (User.Entity.is(result)) {
+     * 	// result: C.Entity<"User">
+     * }
+     * 
+     * const mappedResult = User.Entity.map({
+     * 	id: 3,
+     * 	name: "Eve",
+     * 	roles: ["manager"],
+     * 	nick: null,
+     * ```
+     * 
+     */
     map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
+    /**
+     * Validates raw properties and throws on error.
+     * 
+     * ```ts
+     * const mapped = User.Entity.mapOrThrow({
+     * 	id: 2,
+     * 	name: "Bob",
+     * 	roles: ["client"],
+     * 	nick: "Bobby",
+     * });
+     * ```
+     * 
+     */
     mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+    /**
+    * Checks if a value is an entity of this handler (type guard).
+    * 
+    * ```ts
+    * const result = true ? mapped : null;
+    * 
+    * if (User.Entity.is(result)) {
+    * 	// result: C.Entity<"User">
+    * ```
+    * 
+    */
     is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
 }
 declare const CreateEntityError_base: new (params: {
@@ -70,6 +138,79 @@ export interface PropertiesDefinitionParams {
         inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
     };
 }
+/**
+ * Creates an entity handler from a property definition.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createEntity(name, getPropertiesDefinition)` -> returns a handler
+ * 
+ * Entities model business structures by composing NewTypes. The handler builds entities from typed properties or from raw inputs with validation.
+ * 
+ * ```ts
+ * namespace User {
+ * 	export const Id = C.createNewType("user-id", DP.number(), C.Positive);
+ * 	export type Id = C.GetNewType<typeof Id>;
+ * 	export const Name = C.createNewType("user-name", DP.string());
+ * 	export type Name = C.GetNewType<typeof Name>;
+ * 	export const Role = C.createNewType("UserRole", DP.literal(["admin", "client", "manager"]));
+ * 
+ * 	export const Entity = C.createEntity("User", ({ array, nullable }) => ({
+ * 		id: Id,
+ * 		name: Name,
+ * 		roles: array(Role, { min: 1 }),
+ * 		nick: nullable(Name),
+ * 	}));
+ * 	export type Entity = C.GetEntity<typeof Entity>;
+ * 
+ * 	const defaultRole = Role.createOrThrow("client");
+ * 
+ * 	export function create(params: {
+ * 		id: Id;
+ * 		name: Name;
+ * 	}) {
+ * 		return Entity.new({
+ * 			...params,
+ * 			nick: null,
+ * 			roles: [defaultRole],
+ * 		});
+ * 	}
+ * }
+ * 
+ * const mapped = User.Entity.mapOrThrow({
+ * 	id: 2,
+ * 	name: "Bob",
+ * 	roles: ["client"],
+ * 	nick: "Bobby",
+ * });
+ * 
+ * const result = true ? mapped : null;
+ * 
+ * if (User.Entity.is(result)) {
+ * 	// result: C.Entity<"User">
+ * }
+ * 
+ * const mappedResult = User.Entity.map({
+ * 	id: 3,
+ * 	name: "Eve",
+ * 	roles: ["manager"],
+ * 	nick: null,
+ * });
+ * 
+ * if (E.isRight(mappedResult)) {
+ * 	// mappedResult: E.EitherRight<"createEntity", C.Entity<"User">>
+ * }
+ * 
+ * ```
+ * 
+ * @remarks
+ * - The definition callback can use helpers like `array`, `nullable`, and `union` to enrich properties.
+ * - Use `map`/`mapOrThrow` to build from raw inputs; `new` expects already typed values.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/entity
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition & DObject.ForbiddenKey<GenericPropertiesDefinition, "_entityName" | "_flags">): EntityHandler<GenericName, GenericPropertiesDefinition>;
 export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
 export {};

package/dist/clean/entity.mjs

@@ -46,6 +46,9 @@ class CreateEntityError extends kindHeritage("create-entity-error", createErrorK
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createEntity/index.md}
+ */
 function createEntity(name, getPropertiesDefinition) {
     function theNew(properties) {
         return entityKind.addTo(properties, name);

package/dist/clean/flag.cjs

@@ -4,6 +4,9 @@ var kind = require('./kind.cjs');
 
 const flagHandlerKind = kind.createCleanKind("flag-handler");
 const flagKind = kind.createCleanKind("flag");
+/**
+ * {@include clean/createFlag/index.md}
+ */
 function createFlag(name) {
     return flagHandlerKind.setTo({
         name,

package/dist/clean/flag.d.ts

@@ -3,13 +3,109 @@ import { type Entity } from "./entity";
 declare const flagHandlerKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/flag-handler", unknown>>;
 export declare const flagKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsClean/flag", Record<string, unknown>>>;
 export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagHandlerKind.definition> {
+    /**
+     * The flag name stored as the key on the entity.
+     * 
+     */
     readonly name: GenericName;
+    /**
+     * Adds the flag to an entity and returns the enriched entity.
+     * 
+     * ```ts
+     * 	export function isMajor(entity: Entity) {
+     * 		if (C.greaterThan(entity.age, 18)) {
+     * 			return E.success(
+     * 				MajorFlag.append(entity, entity.age),
+     * 			);
+     * ```
+     * 
+     */
     append<GenericInputEntity extends GenericEntity, GenericInputValue extends GenericValue>(entity: GenericInputEntity, ...args: IsEqual<GenericValue, never> extends true ? [] : [GenericInputValue]): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
+    /**
+     * Retrieves the value carried by the flag.
+     * 
+     * ```ts
+     * const flagged = User.MajorFlag.append(user, user.age);
+     * const value = User.MajorFlag.getValue(flagged);
+     * ```
+     * 
+     */
     getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): GetKindValue<typeof flagKind, GenericInputEntity>[GenericName];
     has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
 export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagKind.definition, Record<GenericName, GenericValue>> {
 }
+/**
+ * Creates a flag handler that can attach typed metadata 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.
+ * 
+ * ```ts
+ * namespace User {
+ * 	export const Name = C.createNewType("UserName", DP.string());
+ * 	export type Name = C.GetNewType<typeof Name>;
+ * 
+ * 	export const Age = C.createNewType("UserAge", DP.number(), C.Positive);
+ * 	export type Age = C.GetNewType<typeof Age>;
+ * 
+ * 	export const Entity = C.createEntity("UserEntity", () => ({
+ * 		name: Name,
+ * 		age: Age,
+ * 	}));
+ * 	export type Entity = C.GetEntity<typeof Entity>;
+ * 
+ * 	export const MajorFlag = C.createFlag<
+ * 		Entity, // mandatory
+ * 		"majorUser", // mandatory
+ * 		Age // optional
+ * 	>("majorUser");
+ * 	export type MajorFlag = C.GetFlag<typeof MajorFlag>;
+ * 
+ * 	export function isMajor(entity: Entity) {
+ * 		if (C.greaterThan(entity.age, 18)) {
+ * 			return E.success(
+ * 				MajorFlag.append(entity, entity.age),
+ * 			);
+ * 		}
+ * 		return E.left("not-major");
+ * 	}
+ * }
+ * 
+ * function drinkAlcohol(userEntity: User.Entity & User.MajorFlag) {
+ * 	// ...
+ * 	return E.right("not-thirsty-anymore");
+ * }
+ * 
+ * const user = User.Entity.new({
+ * 	name: User.Name.createOrThrow("Julie"),
+ * 	age: User.Age.createOrThrow(35),
+ * });
+ * 
+ * const result = pipe(
+ * 	user,
+ * 	User.isMajor,
+ * 	E.whenIsRight(
+ * 		drinkAlcohol,
+ * 	),
+ * );
+ * // E.EitherLeft<"not-major", undefined> | E.EitherRight<"not-thirsty-anymore", undefined>
+ * 
+ * const flagged = User.MajorFlag.append(user, user.age);
+ * const value = User.MajorFlag.getValue(flagged);
+ * 
+ * ```
+ * 
+ * @remarks
+ * A flag lets you add a marker on an entity after its creation. Its purpose is to indicate that a verification has taken place, or that a particular operation has been performed, without modifying the structure of the entity. If the flag carries a value, `append` requires it and `getValue` retrieves it.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/flag
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createFlag<GenericEntity extends Entity = never, GenericName extends string = never, GenericValue extends unknown = never>(name: Or<[
     IsEqual<GenericEntity, never>,
     IsEqual<GenericName, never>

package/dist/clean/flag.mjs

@@ -2,6 +2,9 @@ import { createCleanKind } from './kind.mjs';
 
 const flagHandlerKind = createCleanKind("flag-handler");
 const flagKind = createCleanKind("flag");
+/**
+ * {@include clean/createFlag/index.md}
+ */
 function createFlag(name) {
     return flagHandlerKind.setTo({
         name,

package/dist/clean/index.cjs

@@ -37,7 +37,9 @@ var timeLessThan = require('./primitive/operations/time/timeLessThan.cjs');
 var timeMin = require('./primitive/operations/time/timeMin.cjs');
 var timeMax = require('./primitive/operations/time/timeMax.cjs');
 
-
+/**
+ * {@include clean/index.md}
+ */
 
 exports.createCleanKind = kind.createCleanKind;
 exports.CreateNewTypeError = newType.CreateNewTypeError;

package/dist/clean/index.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Clean Architecture building blocks for the domain layer: primitives, constraints, NewTypes, entities, flags, repositories, and use cases. The goal is explicit business types with runtime validation and predictable composition.
+ * 
+ * **How to import:**
+ * - From the main entry (namespace style)
+ * - Via direct import for tree-shaking
+ * 
+ * ```ts
+ * import { DClean, C } from "@duplojs/utils";
+ * import * as DClean from "@duplojs/utils/clean";
+ * import * as C from "@duplojs/utils/clean";
+ * ```
+ * 
+ * What you will find in this namespace:
+ * - primitives (`C.String`, `C.Number`, `C.Date`, `C.Time`)
+ * - constraints (`C.Email`, `C.Int`, `C.Positive`, `C.Negative`)
+ * - NewTypes and entities (`C.createNewType`, `C.createEntity`)
+ * - flags, repositories, and use cases (`C.createFlag`, `C.createRepository`, `C.createUseCase`)
+ * - primitive operators (`C.equal`, `C.add`, `C.length`, `C.dateGreaterThan`, `C.timeLessThan`)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean
+ * 
+ * @namespace C
+ * 
+ */
 export * from "./types";
 export * from "./kind";
 export * from "./newType";

package/dist/clean/index.mjs

@@ -34,3 +34,7 @@ export { timeGreaterThan } from './primitive/operations/time/timeGreaterThan.mjs
 export { timeLessThan } from './primitive/operations/time/timeLessThan.mjs';
 export { timeMin } from './primitive/operations/time/timeMin.mjs';
 export { timeMax } from './primitive/operations/time/timeMax.mjs';
+
+/**
+ * {@include clean/index.md}
+ */

package/dist/clean/kind.cjs

@@ -2,6 +2,9 @@
 
 var kind = require('../common/kind.cjs');
 
+/**
+ * {@include clean/createCleanKind/index.md}
+ */
 const createCleanKind = kind.createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsClean");

package/dist/clean/kind.d.ts

@@ -1 +1,34 @@
+/**
+ * Creates a kind namespace scoped to the Clean domain.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createCleanKind(name)` -> returns a kind handler
+ * 
+ * Use it to define Clean-specific kinds so domain tags do not collide with other namespaces.
+ * 
+ * ```ts
+ * const customKind = C.createCleanKind("my-kind");
+ * 
+ * const holder = customKind.setTo({
+ * 	value: 123,
+ * });
+ * 
+ * customKind.has(holder); // true
+ * 
+ * const tagged = customKind.addTo(
+ * 	{ name: "Ada" },
+ * 	"my-kind",
+ * );
+ * customKind.has(tagged); // true
+ * 
+ * const secondKind = C.createCleanKind("other-kind");
+ * secondKind.has(holder); // false
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/createCleanKind
+ * 
+ * @namespace C
+ * 
+ */
 export declare const createCleanKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsClean/${GenericName}`, GenericKindValue>>;

package/dist/clean/kind.mjs

@@ -1,5 +1,8 @@
 import { createKindNamespace } from '../common/kind.mjs';
 
+/**
+ * {@include clean/createCleanKind/index.md}
+ */
 const createCleanKind = createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsClean");

package/dist/clean/newType.cjs

@@ -29,6 +29,9 @@ class CreateNewTypeError extends kind$1.kindHeritage("create-new-type-error", er
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createNewType/index.md}
+ */
 function createNewType(name, dataParser, constraint) {
     const constrains = coalescing.coalescing(constraint ?? []);
     const checkers = flatMap.flatMap(constrains, ({ checkers }) => checkers);