@duplojs/utils 1.6.1 → 1.6.3

package/dist/clean/index.d.ts

@@ -33,3 +33,4 @@ export * from "./repository";
 export * from "./useCase";
 export * from "./flag";
 export * from "./maybe";
+export * from "./toMapDataParser";

package/dist/clean/index.mjs

@@ -1,14 +1,16 @@
 export { createCleanKind } from './kind.mjs';
 export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind } from './newType.mjs';
-export { CreateEntityError, createEntity, entityKind } from './entity/index.mjs';
+export { CreateEntityError, createEntity, entityHandlerKind, entityKind } from './entity/index.mjs';
 export { createRepository, repositoryHandlerKind } from './repository.mjs';
 export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
 export { createFlag, flagKind } from './flag.mjs';
 export { none, some } from './maybe.mjs';
+export { toMapDataParser } from './toMapDataParser.mjs';
 export { entityPropertyArrayKind, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools, entityPropertyIdentifierKind, entityPropertyNullableKind, entityPropertyStructureKind, entityPropertyUnionKind } from './entity/property.mjs';
 export { unwrapEntity, unwrapEntityProperty } from './entity/unwrap.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
-export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt } from './constraint/defaultConstraint/number.mjs';
+export { castConstraint } from './constraint/cast.mjs';
+export { Int, Negative, NumberMax, NumberMin, Positive } from './constraint/defaultConstraint/number.mjs';
 export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';
 export { NegativeTime, PositiveTime } from './constraint/defaultConstraint/time.mjs';
 export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet } from './constraint/set.mjs';

package/dist/clean/newType.cjs

@@ -35,7 +35,7 @@ class CreateNewTypeError extends kind$1.kindHeritage("create-new-type-error", er
  */
 function createNewType(name, dataParser, constraint) {
     const constraints = coalescing.coalescing(constraint ?? []);
-    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
+    const checkers = flatMap.flatMap(constraints, ({ internal }) => internal.checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
@@ -85,6 +85,11 @@ function createNewType(name, dataParser, constraint) {
         name,
         dataParser: dataParserWithCheckers,
         constraints,
+        internal: {
+            dataParser: dataParserWithCheckers,
+            constraints,
+            constraintKindValue,
+        },
         getConstraint,
         create: create$2,
         createOrThrow,

package/dist/clean/newType.d.ts

@@ -17,15 +17,30 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      */
     readonly name: GenericName;
     /**
-     * The DataParser used to validate and transform raw inputs.
-     * 
+     * @deprecated
      */
     readonly dataParser: DDataParser.Contract<GenericValue, unknown>;
     /**
-     * The list of constraints applied to this NewType.
-     * 
+     * @deprecated
      */
     readonly constraints: GenericConstraintsHandler;
+    readonly internal: {
+        /**
+         * The DataParser used to validate and transform raw inputs.
+         * 
+         */
+        readonly dataParser: DDataParser.Contract<GenericValue, unknown>;
+        /**
+         * The list of constraints applied to this NewType.
+         * 
+         */
+        readonly constraints: GenericConstraintsHandler;
+        /**
+         * The constraint kind metadata applied to this NewType.
+         * 
+         */
+        readonly constraintKindValue: Record<string, null>;
+    };
     /**
      * Creates a NewType value and returns an Either.
      * 
@@ -156,5 +171,5 @@ export declare function createNewType<GenericName extends string, GenericDataPar
 export declare namespace createNewType {
     var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[], unknown>[], unknown>>;
 }
-export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>, GenericValue extends DDataParser.Output<GenericHandler["dataParser"]> = DDataParser.Output<GenericHandler["dataParser"]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], GenericValue, GenericHandler["constraints"][number]["name"]> : never, any>;
+export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>, GenericValue extends DDataParser.Output<GenericHandler["internal"]["dataParser"]> = DDataParser.Output<GenericHandler["internal"]["dataParser"]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], GenericValue, GenericHandler["internal"]["constraints"][number]["name"]> : never, any>;
 export {};

package/dist/clean/newType.mjs

@@ -33,7 +33,7 @@ class CreateNewTypeError extends kindHeritage("create-new-type-error", createErr
  */
 function createNewType(name, dataParser, constraint) {
     const constraints = coalescing(constraint ?? []);
-    const checkers = flatMap(constraints, ({ checkers }) => checkers);
+    const checkers = flatMap(constraints, ({ internal }) => internal.checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
@@ -83,6 +83,11 @@ function createNewType(name, dataParser, constraint) {
         name,
         dataParser: dataParserWithCheckers,
         constraints,
+        internal: {
+            dataParser: dataParserWithCheckers,
+            constraints,
+            constraintKindValue,
+        },
         getConstraint,
         create,
         createOrThrow,

package/dist/clean/primitive/operations/equal.cjs

@@ -8,6 +8,9 @@ function equal(...args) {
         return (input) => equal(input, value);
     }
     const [input, value] = args;
+    if (input === null || value === null) {
+        return input === value;
+    }
     return unwrap.unwrap(input).toString() === unwrap.unwrap(value).toString();
 }
 

package/dist/clean/primitive/operations/equal.d.ts

@@ -34,5 +34,5 @@ import { type Primitive, type Primitives } from "../base";
  * @namespace C
  * 
  */
-export declare function equal<GenericInput extends Primitives, GenericValue extends (Primitive<Unwrap<GenericInput>> | Unwrap<GenericInput>)>(value: GenericValue): (input: GenericInput) => input is GenericInput & Primitive<Unwrap<GenericValue>>;
-export declare function equal<GenericInput extends Primitives, GenericValue extends (Primitive<Unwrap<GenericInput>> | Unwrap<GenericInput>)>(input: GenericInput, value: GenericValue): input is GenericInput & Primitive<Unwrap<GenericValue>>;
+export declare function equal<GenericInput extends Primitives | null, const GenericValue extends (Primitive<Unwrap<Exclude<GenericInput, null>>> | Unwrap<GenericInput>)>(value: GenericValue): (input: GenericInput) => input is (GenericInput & (GenericValue extends null ? GenericValue : Primitive<Unwrap<Exclude<GenericValue, null>>>));
+export declare function equal<GenericInput extends Primitives | null, const GenericValue extends (Primitive<Unwrap<Exclude<GenericInput, null>>> | Unwrap<GenericInput>)>(input: GenericInput, value: GenericValue): input is (GenericInput & (GenericValue extends null ? GenericValue : Primitive<Unwrap<Exclude<GenericValue, null>>>));

package/dist/clean/primitive/operations/equal.mjs

@@ -6,6 +6,9 @@ function equal(...args) {
         return (input) => equal(input, value);
     }
     const [input, value] = args;
+    if (input === null || value === null) {
+        return input === value;
+    }
     return unwrap(input).toString() === unwrap(value).toString();
 }
 

package/dist/clean/toMapDataParser.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var newType = require('./newType.cjs');
+var base = require('./primitive/base.cjs');
+var base$1 = require('./constraint/base.cjs');
+var set = require('./constraint/set.cjs');
+var hasSomeKinds = require('../common/hasSomeKinds.cjs');
+var index = require('../pattern/match/index.cjs');
+var transform = require('../dataParser/parsers/transform.cjs');
+var index$1 = require('../dataParser/parsers/string/index.cjs');
+var index$2 = require('../dataParser/parsers/number/index.cjs');
+var index$3 = require('../dataParser/parsers/bigint/index.cjs');
+var boolean = require('../dataParser/parsers/boolean.cjs');
+var date = require('../dataParser/parsers/date.cjs');
+var index$4 = require('../dataParser/parsers/time/index.cjs');
+var empty = require('../dataParser/parsers/empty.cjs');
+var nil = require('../dataParser/parsers/nil.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+
+function toMapDataParser(input, params) {
+    const dataParser = (base.primitiveHandlerKind.has(input)
+        ? input.dataParser.clone()
+        : input.internal.dataParser.clone());
+    if (params?.coerce
+        && hasSomeKinds.hasSomeKinds(dataParser, [
+            index$1.stringKind,
+            index$2.numberKind,
+            index$3.bigIntKind,
+            index$3.bigIntKind,
+            boolean.booleanKind,
+            date.dateKind,
+            index$4.timeKind,
+            empty.emptyKind,
+            nil.nilKind,
+        ])) {
+        dataParser.definition.coerce = true;
+    }
+    const valueContainer = index.match(input)
+        .when(newType.newTypeHandlerKind.has, (newType$1) => ({
+        ...newType.newTypeKind.setTo({}, newType$1.name),
+        ...base$1.constrainedTypeKind.setTo({}, newType$1.internal.constraintKindValue),
+    }))
+        .when(hasSomeKinds.hasSomeKinds([base$1.constraintHandlerKind, set.constraintsSetHandlerKind]), (constraintOrSet) => base$1.constrainedTypeKind.setTo({}, constraintOrSet.internal.constraintKindValue))
+        .when(base.primitiveHandlerKind.has, () => ({}))
+        .exhaustive();
+    return transform.transform(dataParser, (value) => ({
+        ...valueContainer,
+        [wrapValue.keyWrappedValue]: value,
+    }));
+}
+
+exports.toMapDataParser = toMapDataParser;

package/dist/clean/toMapDataParser.d.ts

@@ -0,0 +1,53 @@
+import * as DDataParser from "../dataParser";
+import { type ConstraintHandler, type ConstraintsSetHandler, type GetConstraint, type GetConstraints } from "./constraint";
+import { type GetNewType, type NewTypeHandler } from "./newType";
+import { type PrimitiveHandler } from "./primitive";
+type ToMapDataParserInput = NewTypeHandler<any, any, readonly any[], any> | ConstraintHandler<any, any, readonly any[], any> | ConstraintsSetHandler<any, readonly any[], any> | PrimitiveHandler;
+type OutputDataParser<GenericInput extends ToMapDataParserInput> = GenericInput extends NewTypeHandler<any, any, readonly any[], any> ? GetNewType<GenericInput> : GenericInput extends ConstraintHandler<any, any, readonly any[], any> ? GetConstraint<GenericInput> : GenericInput extends ConstraintsSetHandler<any, readonly any[], any> ? GetConstraints<GenericInput> : GenericInput extends PrimitiveHandler ? ReturnType<GenericInput["createWithUnknownOrThrow"]> : never;
+interface ToMapDataParserParams {
+    coerce?: boolean;
+}
+/**
+ * Creates a DataParser that maps Clean handlers or primitives into a wrapped value object.
+ * 
+ * **Supported call styles:**
+ * - Classic: `toMapDataParser(handler, params?)` -> returns a DataParser
+ * - Pipe: `pipe(handler, toMapDataParser)` -> returns a DataParser
+ * 
+ * The resulting parser preserves kind tags (`newTypeKind`, `constrainedTypeKind`) and stores the parsed value under the wrapped value key. When `coerce` is enabled, compatible primitive parsers will coerce inputs before validation.
+ * 
+ * ```ts
+ * const ShortLabel = C.createNewType(
+ * 	"ShortLabel",
+ * 	DP.string(),
+ * 	[C.StringMax(5)],
+ * );
+ * 
+ * const labelParser = C.toMapDataParser(ShortLabel);
+ * labelParser.parseOrThrow("hello");
+ * 
+ * const userIdParser = pipe(
+ * 	C.Number,
+ * 	C.toMapDataParser,
+ * );
+ * userIdParser.parseOrThrow(42);
+ * 
+ * const coerceParser = C.toMapDataParser(
+ * 	C.String,
+ * 	{ coerce: true },
+ * );
+ * coerceParser.parseOrThrow(123);
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Supported inputs: `NewTypeHandler`, `ConstraintHandler`, `ConstraintsSetHandler`, and `PrimitiveHandler`.
+ * - Use `coerce: true` to allow conversions (e.g. number to string) on compatible parsers.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/toMapDataParser
+ * 
+ * @namespace C
+ * 
+ */
+export declare function toMapDataParser<GenericInput extends ToMapDataParserInput, GenericInputDataParser extends unknown = unknown>(input: GenericInput, params?: ToMapDataParserParams): DDataParser.Contract<OutputDataParser<GenericInput>, GenericInputDataParser>;
+export {};

package/dist/clean/toMapDataParser.mjs

@@ -0,0 +1,50 @@
+import { newTypeHandlerKind, newTypeKind } from './newType.mjs';
+import { primitiveHandlerKind } from './primitive/base.mjs';
+import { constrainedTypeKind, constraintHandlerKind } from './constraint/base.mjs';
+import { constraintsSetHandlerKind } from './constraint/set.mjs';
+import { hasSomeKinds } from '../common/hasSomeKinds.mjs';
+import { match } from '../pattern/match/index.mjs';
+import { transform } from '../dataParser/parsers/transform.mjs';
+import { stringKind } from '../dataParser/parsers/string/index.mjs';
+import { numberKind } from '../dataParser/parsers/number/index.mjs';
+import { bigIntKind } from '../dataParser/parsers/bigint/index.mjs';
+import { booleanKind } from '../dataParser/parsers/boolean.mjs';
+import { dateKind } from '../dataParser/parsers/date.mjs';
+import { timeKind } from '../dataParser/parsers/time/index.mjs';
+import { emptyKind } from '../dataParser/parsers/empty.mjs';
+import { nilKind } from '../dataParser/parsers/nil.mjs';
+import { keyWrappedValue } from '../common/wrapValue.mjs';
+
+function toMapDataParser(input, params) {
+    const dataParser = (primitiveHandlerKind.has(input)
+        ? input.dataParser.clone()
+        : input.internal.dataParser.clone());
+    if (params?.coerce
+        && hasSomeKinds(dataParser, [
+            stringKind,
+            numberKind,
+            bigIntKind,
+            bigIntKind,
+            booleanKind,
+            dateKind,
+            timeKind,
+            emptyKind,
+            nilKind,
+        ])) {
+        dataParser.definition.coerce = true;
+    }
+    const valueContainer = match(input)
+        .when(newTypeHandlerKind.has, (newType) => ({
+        ...newTypeKind.setTo({}, newType.name),
+        ...constrainedTypeKind.setTo({}, newType.internal.constraintKindValue),
+    }))
+        .when(hasSomeKinds([constraintHandlerKind, constraintsSetHandlerKind]), (constraintOrSet) => constrainedTypeKind.setTo({}, constraintOrSet.internal.constraintKindValue))
+        .when(primitiveHandlerKind.has, () => ({}))
+        .exhaustive();
+    return transform(dataParser, (value) => ({
+        ...valueContainer,
+        [keyWrappedValue]: value,
+    }));
+}
+
+export { toMapDataParser };

package/dist/common/asserts.cjs

@@ -18,6 +18,18 @@ function asserts(input, predicate) {
         throw new AssertsError(input);
     }
 }
+function forwardAsserts(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => forwardAsserts(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (!theFunction(input)) {
+        throw new AssertsError(input);
+    }
+    return input;
+}
 
 exports.AssertsError = AssertsError;
 exports.asserts = asserts;
+exports.forwardAsserts = forwardAsserts;

package/dist/common/asserts.d.ts

@@ -33,4 +33,30 @@ export declare class AssertsError extends AssertsError_base {
  * 
  */
 export declare function asserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): asserts input is GenericPredicate;
+/**
+ * The forwardAsserts() function throws when a predicate fails and returns the validated input. It supports classic and curried forms, with type-guard and boolean predicates.
+ * 
+ * **Supported call styles:**
+ * - Classic: `forwardAsserts(input, predicate)` → returns the narrowed input or throws
+ * - Curried: `forwardAsserts(predicate)(input)` → returns the validated input or throws
+ * 
+ * It is useful when you want both runtime validation and a returned value you can keep using directly, especially inside `pipe()`. With a type guard predicate, the return type is narrowed. With a boolean predicate, the original input type is preserved. It throws an `AssertsError` with the failing input value.
+ * 
+ * ```ts
+ * const input = "demo" as string | number;
+ * const result = forwardAsserts(input, isType("string"));
+ * 
+ * const pipedResult = pipe(
+ * 	"admin" as string | number,
+ * 	forwardAsserts(isType("string")),
+ * );
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/forwardAsserts
+ * 
+ */
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(predicate: (input: GenericInput) => input is GenericPredicate): (input: GenericInput) => GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(predicate: (input: GenericInput) => boolean): (input: GenericInput) => GenericInput;
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(input: GenericInput, predicate: (input: GenericInput) => boolean): GenericInput;
 export {};

package/dist/common/asserts.mjs

@@ -16,5 +16,16 @@ function asserts(input, predicate) {
         throw new AssertsError(input);
     }
 }
+function forwardAsserts(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => forwardAsserts(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (!theFunction(input)) {
+        throw new AssertsError(input);
+    }
+    return input;
+}
 
-export { AssertsError, asserts };
+export { AssertsError, asserts, forwardAsserts };

package/dist/common/callThen.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * {@include common/callThen/index.md}
+ */
+function callThen(input, TheFunction) {
+    if (input instanceof Promise) {
+        return input
+            .then(TheFunction);
+    }
+    return TheFunction(input);
+}
+
+exports.callThen = callThen;

package/dist/common/callThen.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The callThen() function applies a callback to a value immediately, or waits for a promise input before running the same callback.
+ * 
+ * Supported call styles:
+ * - Classic: `callThen(input, callback)` → returns a value or a promise depending on the input and callback
+ * 
+ * Behavior:
+ * - direct values call the callback synchronously
+ * - `Promise` inputs call the callback through `.then(...)`
+ * - callback promises are preserved for direct values and flattened for `Promise` inputs
+ * 
+ * ```ts
+ * const syncResult = callThen(
+ * 	2,
+ * 	(value) => value * 3,
+ * );
+ * // type: number
+ * 
+ * const asyncFromSync = callThen(
+ * 	"duplo",
+ * 	async(value) => Promise.resolve(value.toUpperCase()),
+ * );
+ * // type: Promise<string>
+ * 
+ * const asyncFromPromise = callThen(
+ * 	Promise.resolve({
+ * 		count: 2,
+ * 	}),
+ * 	({ count }) => count + 1,
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/callThen
+ * 
+ */
+export declare function callThen<GenericInput extends unknown, GenericOutput extends unknown>(input: GenericInput, TheFunction: (input: Awaited<GenericInput>) => GenericOutput): GenericInput extends Promise<unknown> ? Promise<Awaited<GenericOutput>> : GenericOutput;

package/dist/common/callThen.mjs

@@ -0,0 +1,12 @@
+/**
+ * {@include common/callThen/index.md}
+ */
+function callThen(input, TheFunction) {
+    if (input instanceof Promise) {
+        return input
+            .then(TheFunction);
+    }
+    return TheFunction(input);
+}
+
+export { callThen };

package/dist/common/index.d.ts

@@ -78,3 +78,6 @@ export * from "./path";
 export * from "./transformer";
 export * from "./toRegExp";
 export * from "./justExec";
+export * from "./callThen";
+export * from "./queue";
+export * from "./printer";

package/dist/common/printer.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var repeat = require('../string/repeat.cjs');
+
+exports.Printer = void 0;
+(function (Printer) {
+    const codeColors = {
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        cyan: "\x1b[36m",
+        gray: "\x1b[90m",
+    };
+    const codeBold = "\x1b[1m";
+    const codeReset = "\x1b[0m";
+    Printer.tab = "\t";
+    Printer.back = "\n";
+    Printer.dash = "-";
+    function colorized(...args) {
+        if (args.length === 1) {
+            const [color] = args;
+            return (input) => colorized(input, color);
+        }
+        const [input, color] = args;
+        return `${codeColors[color]}${input}${codeReset}`;
+    }
+    Printer.colorized = colorized;
+    /**
+     * {@include common/printer/bold/index.md}
+     */
+    function bold(input) {
+        return `${codeBold}${input}${codeReset}`;
+    }
+    Printer.bold = bold;
+    function colorizedBold(...args) {
+        if (args.length === 1) {
+            const [color] = args;
+            return (input) => colorizedBold(input, color);
+        }
+        const [input, color] = args;
+        return bold(colorized(input, color));
+    }
+    Printer.colorizedBold = colorizedBold;
+    function indent(level) {
+        return repeat.repeat(Printer.tab, level);
+    }
+    Printer.indent = indent;
+    function stringify(value) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    Printer.stringify = stringify;
+    function render(...args) {
+        if (args.length === 1) {
+            const [joinCharacter] = args;
+            return (values) => render(values, joinCharacter);
+        }
+        const [values, joinCharacter] = args;
+        return values
+            .flat(Infinity)
+            .filter((value) => typeof value === "string" || value === true)
+            .join(joinCharacter);
+    }
+    Printer.render = render;
+    Printer.renderLine = render(" ");
+    Printer.renderParagraph = render(Printer.back);
+})(exports.Printer || (exports.Printer = {}));

package/dist/common/printer.d.ts

@@ -0,0 +1,139 @@
+export declare namespace Printer {
+    const codeColors: {
+        readonly red: "\u001B[31m";
+        readonly green: "\u001B[32m";
+        readonly yellow: "\u001B[33m";
+        readonly blue: "\u001B[34m";
+        readonly magenta: "\u001B[35m";
+        readonly cyan: "\u001B[36m";
+        readonly gray: "\u001B[90m";
+    };
+    export const tab = "\t";
+    export const back = "\n";
+    export const dash = "-";
+    export type Colors = keyof typeof codeColors;
+    /**
+     * Wraps a string with the ANSI escape sequence of the selected color. Exists in immediate or curried form.
+     * 
+     * **Supported call styles:**
+     * - Classic: `Printer.colorized(input, color)` -> returns the colored string
+     * - Curried: `Printer.colorized(color)` -> returns a function waiting for the string
+     * 
+     * The function only adds the opening color code and the reset code around the input string.
+     * 
+     * ```ts
+     * const directResult = Printer.colorized("Hello", "green");
+     * // directResult: "\x1b[32mHello\x1b[0m"
+     * 
+     * const pipedResult = pipe(
+     * 	"Warning",
+     * 	Printer.colorized("yellow"),
+     * );
+     * // pipedResult: "\x1b[33mWarning\x1b[0m"
+     * 
+     * const errorResult = Printer.colorized("Error", "red");
+     * // errorResult: "\x1b[31mError\x1b[0m"
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/printer/colorized
+     * 
+     */
+    export function colorized<GenericInput extends string>(color: Colors): (input: GenericInput) => string;
+    export function colorized<GenericInput extends string>(input: GenericInput, color: Colors): string;
+    /**
+     * Wraps a string with the ANSI escape sequence for bold text.
+     * 
+     * Signature: `Printer.bold(input)` -> returns the bold string
+     * 
+     * The function prepends the bold code and appends the reset code without altering the input content.
+     * 
+     * ```ts
+     * const title = Printer.bold("Build report");
+     * // title: "\x1b[1mBuild report\x1b[0m"
+     * 
+     * const symbol = Printer.bold("!");
+     * // symbol: "\x1b[1m!\x1b[0m"
+     * 
+     * const empty = Printer.bold("");
+     * // empty: "\x1b[1m\x1b[0m"
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/printer/bold
+     * 
+     */
+    export function bold(input: string): string;
+    /**
+     * Applies a color and bold formatting to a string by combining `Printer.colorized()` and `Printer.bold()`. Exists in immediate or curried form.
+     * 
+     * **Supported call styles:**
+     * - Classic: `Printer.colorizedBold(input, color)` -> returns the formatted string
+     * - Curried: `Printer.colorizedBold(color)` -> returns a function waiting for the string
+     * 
+     * The produced string contains the bold ANSI code, then the colorized content, and finally the reset codes.
+     * 
+     * ```ts
+     * const directResult = Printer.colorizedBold("Fatal", "red");
+     * // directResult: "\x1b[1m\x1b[31mFatal\x1b[0m\x1b[0m"
+     * 
+     * const pipedResult = pipe(
+     * 	"Info",
+     * 	Printer.colorizedBold("cyan"),
+     * );
+     * // pipedResult: "\x1b[1m\x1b[36mInfo\x1b[0m\x1b[0m"
+     * 
+     * const successResult = Printer.colorizedBold("Done", "green");
+     * // successResult: "\x1b[1m\x1b[32mDone\x1b[0m\x1b[0m"
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/printer/colorizedBold
+     * 
+     */
+    export function colorizedBold<GenericInput extends string>(color: Colors): (input: GenericInput) => string;
+    export function colorizedBold<GenericInput extends string>(input: GenericInput, color: Colors): string;
+    export function indent(level: number): string;
+    export function stringify(value: unknown): string;
+    export type RenderInput = string | boolean | null | undefined | RenderInput[];
+    /**
+     * Flattens printable values, keeps strings and `true`, then joins the result with a custom separator. Exists in immediate or curried form.
+     * 
+     * **Supported call styles:**
+     * - Classic: `Printer.render(values, joinCharacter)` -> returns the rendered string
+     * - Curried: `Printer.render(joinCharacter)` -> returns a function waiting for the values array
+     * 
+     * Nested arrays are flattened recursively. `false`, `null`, and `undefined` are ignored, while `true` is kept as the string `"true"`.
+     * The namespace also exposes two ready-to-use defaults: `Printer.renderLine`, which joins with a space, and `Printer.renderParagraph`, which joins with `Printer.back`.
+     * 
+     * ```ts
+     * const customResult = Printer.render(
+     * 	["alpha", ["beta", false], true, undefined],
+     * 	" | ",
+     * );
+     * // customResult: "alpha | beta | true"
+     * 
+     * const lineResult = Printer.renderLine([
+     * 	"hello",
+     * 	["world", null],
+     * 	true,
+     * ]);
+     * // lineResult: "hello world true"
+     * 
+     * const paragraphResult = pipe(
+     * 	["title", ["", "body"], false, true] as const,
+     * 	Printer.renderParagraph,
+     * );
+     * // paragraphResult: "title\n\nbody\ntrue"
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/printer/render
+     * 
+     */
+    export function render<GenericValues extends readonly RenderInput[]>(joinCharacter: string): (values: GenericValues) => string;
+    export function render<GenericValues extends readonly RenderInput[]>(values: GenericValues, joinCharacter: string): string;
+    export const renderLine: (values: readonly RenderInput[]) => string;
+    export const renderParagraph: (values: readonly RenderInput[]) => string;
+    export {};
+}