@duplojs/utils 1.4.32 → 1.4.33

package/dist/dataParser/extended/array.d.ts

@@ -19,13 +19,97 @@ export interface DataParserArrayExtended<GenericDefinition extends dataParsers.D
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * Adds a minimum length checker to an array parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns an array parser
+     * 
+     * Ensures the array length is at least the given minimum.
+     * 
+     * ```ts
+     * const parser = DPE.array(DPE.string()).min(2);
+     * const result = parser.parse(["a", "b"]);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: string[]
+     * }
+     * 
+     * const numbers = DPE.array(DPE.number()).min(1);
+     * const numbersResult = numbers.parse([1]);
+     * 
+     * const nested = DPE.array(DPE.array(DPE.boolean())).min(1);
+     * const nestedResult = nested.parse([[true]]);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/array
+     * 
+     * @namespace DPE
+     * 
+     */
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMin, "min">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerArrayMin
     ]>>;
+    /**
+     * Adds a maximum length checker to an array parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns an array parser
+     * 
+     * Ensures the array length is at most the given maximum.
+     * 
+     * ```ts
+     * const parser = DPE.array(DPE.string()).max(2);
+     * const result = parser.parse(["a", "b"]);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: string[]
+     * }
+     * 
+     * const numbers = DPE.array(DPE.number()).max(3);
+     * const numbersResult = numbers.parse([1, 2, 3]);
+     * 
+     * const nested = DPE.array(DPE.array(DPE.boolean())).max(1);
+     * const nestedResult = nested.parse([[true]]);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/array
+     * 
+     * @namespace DPE
+     * 
+     */
     max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMax, "max">>): DataParserArrayExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerArrayMax
     ]>>;
 }
+/**
+ * Creates an extended data parser for arrays.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.array(element, definition?)` -> returns an array parser
+ * 
+ * Validates arrays and exposes array-specific methods like min and max.
+ * 
+ * ```ts
+ * const parser = DPE.array(DPE.string()).min(1).max(3);
+ * const result = parser.parse(["a", "b"]);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string[]
+ * }
+ * 
+ * const numbers = DPE.array(DPE.number()).min(2);
+ * const numbersResult = numbers.parse([1, 2, 3]);
+ * 
+ * const nested = DPE.array(DPE.array(DPE.boolean()));
+ * const nestedResult = nested.parse([[true, false]]);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/array
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
     element: GenericElement;
 }>>;

package/dist/dataParser/extended/array.mjs

@@ -4,6 +4,9 @@ import { checkerArrayMax } from '../parsers/array/checkers/max.mjs';
 import { checkerArrayMin } from '../parsers/array/checkers/min.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/array/index.md}
+ */
 function array(element, definition) {
     const self = dataParserExtendedInit(array$1(element, definition), {
         min(self, min, definition) {

package/dist/dataParser/extended/bigint.cjs

@@ -6,6 +6,9 @@ var max = require('../parsers/bigint/checkers/max.cjs');
 var min = require('../parsers/bigint/checkers/min.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/bigint/index.md}
+ */
 function bigint(definition) {
     const self = baseExtended.dataParserExtendedInit(index.bigint(definition), {
         min(self, min$1, definition) {

package/dist/dataParser/extended/bigint.d.ts

@@ -19,13 +19,97 @@ export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * Adds a minimum value checker to a bigint parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns a bigint parser
+     * 
+     * Ensures the bigint is at least the given minimum.
+     * 
+     * ```ts
+     * const parser = DPE.bigint().min(1n);
+     * const result = parser.parse(5n);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: bigint
+     * }
+     * 
+     * const withMessage = DPE.bigint().min(10n, { errorMessage: "bigint.too-small" });
+     * const messageResult = withMessage.parse(10n);
+     * 
+     * const chained = DPE.bigint().min(1n).max(5n);
+     * const chainedResult = chained.parse(3n);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/bigint
+     * 
+     * @namespace DPE
+     * 
+     */
     min(min: bigint, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionBigIntMin, "min">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerBigIntMin
     ]>>;
+    /**
+     * Adds a maximum value checker to a bigint parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns a bigint parser
+     * 
+     * Ensures the bigint is at most the given maximum.
+     * 
+     * ```ts
+     * const parser = DPE.bigint().max(10n);
+     * const result = parser.parse(5n);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: bigint
+     * }
+     * 
+     * const withMessage = DPE.bigint().max(100n, { errorMessage: "bigint.too-large" });
+     * const messageResult = withMessage.parse(100n);
+     * 
+     * const chained = DPE.bigint().min(1n).max(5n);
+     * const chainedResult = chained.parse(2n);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/bigint
+     * 
+     * @namespace DPE
+     * 
+     */
     max(max: bigint, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionBigIntMax, "max">>): DataParserBigIntExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerBigIntMax
     ]>>;
 }
+/**
+ * Creates an extended data parser for bigint values.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.bigint(definition?)` -> returns a bigint parser
+ * 
+ * Validates bigint values and exposes bigint-specific methods like min and max.
+ * 
+ * ```ts
+ * const parser = DPE.bigint().min(1n).max(10n);
+ * const result = parser.parse(5n);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: bigint
+ * }
+ * 
+ * const coerceParser = DPE.coerce.bigint();
+ * const coerceResult = coerceParser.parse("42");
+ * 
+ * const onlySmall = DPE.bigint().max(3n);
+ * const smallResult = onlySmall.parse(2n);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/bigint
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function bigint<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionBigInt> = never>(definition?: GenericDefinition): DataParserBigIntExtended<MergeDefinition<dataParsers.DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace bigint {
     var overrideHandler: import("../../common").OverrideHandler<DataParserBigIntExtended<dataParsers.DataParserDefinitionBigInt>>;

package/dist/dataParser/extended/bigint.mjs

@@ -4,6 +4,9 @@ import { checkerBigIntMax } from '../parsers/bigint/checkers/max.mjs';
 import { checkerBigIntMin } from '../parsers/bigint/checkers/min.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/bigint/index.md}
+ */
 function bigint(definition) {
     const self = dataParserExtendedInit(bigint$1(definition), {
         min(self, min, definition) {

package/dist/dataParser/extended/boolean.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var boolean$1 = require('../parsers/boolean.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/boolean/index.md}
+ */
 function boolean(definition) {
     const self = baseExtended.dataParserExtendedInit(boolean$1.boolean(definition), {});
     return boolean.overrideHandler.apply(self);

package/dist/dataParser/extended/boolean.d.ts

@@ -20,6 +20,34 @@ export interface DataParserBooleanExtended<GenericDefinition extends dataParsers
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser for boolean values.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.boolean(definition?)` -> returns a boolean parser
+ * 
+ * Validates boolean values and can be combined with extended helpers like optional or nullable.
+ * 
+ * ```ts
+ * const parser = DPE.boolean();
+ * const result = parser.parse(true);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: boolean
+ * }
+ * 
+ * const coerceParser = DPE.coerce.boolean();
+ * const coerceResult = coerceParser.parse("false");
+ * 
+ * const optionalBool = DPE.boolean().optional();
+ * const optionalResult = optionalBool.parse(undefined);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/boolean
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function boolean<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBooleanExtended<MergeDefinition<dataParsers.DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace boolean {
     var overrideHandler: import("../../common").OverrideHandler<DataParserBooleanExtended<dataParsers.DataParserDefinitionBoolean>>;

package/dist/dataParser/extended/boolean.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { boolean as boolean$1 } from '../parsers/boolean.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/boolean/index.md}
+ */
 function boolean(definition) {
     const self = dataParserExtendedInit(boolean$1(definition), {});
     return boolean.overrideHandler.apply(self);

package/dist/dataParser/extended/date.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var date$1 = require('../parsers/date.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/date/index.md}
+ */
 function date(definition) {
     const self = baseExtended.dataParserExtendedInit(date$1.date(definition), {});
     return date.overrideHandler.apply(self);

package/dist/dataParser/extended/date.d.ts

@@ -21,6 +21,34 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser for TheDate values.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.date(definition?)` -> returns a date parser
+ * 
+ * Validates TheDate values and can coerce from string or timestamp when enabled.
+ * 
+ * ```ts
+ * const parser = DPE.date();
+ * const result = parser.parse("date0+");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: TheDate
+ * }
+ * 
+ * const coerceParser = DPE.coerce.date();
+ * const coerceResult = coerceParser.parse("2024-01-01T00:00:00.000Z");
+ * 
+ * const nullableDate = DPE.date().nullable();
+ * const nullableResult = nullableDate.parse(null);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/date
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function date<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionDate> = never>(definition?: GenericDefinition): DataParserDateExtended<MergeDefinition<dataParsers.DataParserDefinitionDate, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace date {
     var overrideHandler: import("../../common").OverrideHandler<DataParserDateExtended<dataParsers.DataParserDefinitionDate>>;

package/dist/dataParser/extended/date.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { date as date$1 } from '../parsers/date.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/date/index.md}
+ */
 function date(definition) {
     const self = dataParserExtendedInit(date$1(definition), {});
     return date.overrideHandler.apply(self);

package/dist/dataParser/extended/empty.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var empty$1 = require('../parsers/empty.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/empty/index.md}
+ */
 function empty(definition) {
     const self = baseExtended.dataParserExtendedInit(empty$1.empty(definition), {});
     return empty.overrideHandler.apply(self);

package/dist/dataParser/extended/empty.d.ts

@@ -20,6 +20,33 @@ export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.D
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser that accepts undefined.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.empty(definition?)` -> returns an empty parser
+ * 
+ * Accepts undefined (or the string "undefined" when coerce is enabled).
+ * 
+ * ```ts
+ * const parser = DPE.empty();
+ * const result = parser.parse(undefined);
+ * if (E.isRight(result)) {
+ * 	// E.EitherSuccess<undefined>
+ * }
+ * 
+ * const coerceParser = DPE.coerce.empty();
+ * const coerceResult = coerceParser.parse("undefined");
+ * 
+ * const optionalEmpty = DPE.empty().optional();
+ * const optionalResult = optionalEmpty.parse(undefined);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/empty
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function empty<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace empty {
     var overrideHandler: import("../../common").OverrideHandler<DataParserEmptyExtended<dataParsers.DataParserDefinitionEmpty>>;

package/dist/dataParser/extended/empty.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { empty as empty$1 } from '../parsers/empty.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/empty/index.md}
+ */
 function empty(definition) {
     const self = dataParserExtendedInit(empty$1(definition), {});
     return empty.overrideHandler.apply(self);

package/dist/dataParser/extended/lazy.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var lazy$1 = require('../parsers/lazy.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/lazy/index.md}
+ */
 function lazy(getter, definition) {
     const self = baseExtended.dataParserExtendedInit(lazy$1.lazy(getter, definition), {});
     return lazy.overrideHandler.apply(self);

package/dist/dataParser/extended/lazy.d.ts

@@ -20,6 +20,44 @@ export interface DataParserLazyExtended<GenericDefinition extends dataParsers.Da
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended lazy data parser resolved at runtime.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.lazy(getter, definition?)` -> returns a lazy parser
+ * 
+ * Defers parser creation until execution, useful for recursive schemas.
+ * 
+ * ```ts
+ * const parser = DPE.lazy(() => DPE.string());
+ * const result = parser.parse("lazy");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * interface RecursiveSchema {
+ * 	value: number;
+ * 	next?: RecursiveSchema;
+ * }
+ * 
+ * const recursive: DPE.Contract<RecursiveSchema> = DPE.lazy(
+ * 	() => DPE.object({
+ * 		value: DPE.number(),
+ * 		next: DPE.optional(recursive),
+ * 	}),
+ * );
+ * const recursiveResult = recursive.parse({
+ * 	value: 1,
+ * 	next: { value: 2 },
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/lazy
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter: Memoized<GenericDataParser>;
 }>>;

package/dist/dataParser/extended/lazy.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { lazy as lazy$1 } from '../parsers/lazy.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/lazy/index.md}
+ */
 function lazy(getter, definition) {
     const self = dataParserExtendedInit(lazy$1(getter, definition), {});
     return lazy.overrideHandler.apply(self);

package/dist/dataParser/extended/literal.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var literal$1 = require('../parsers/literal.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/literal/index.md}
+ */
 function literal(value, definition) {
     const self = baseExtended.dataParserExtendedInit(literal$1.literal(value, definition), {});
     return literal.overrideHandler.apply(self);

package/dist/dataParser/extended/literal.d.ts

@@ -20,6 +20,34 @@ export interface DataParserLiteralExtended<GenericDefinition extends dataParsers
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser for a literal value.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.literal(value)` -> returns a literal parser
+ * 
+ * Accepts only the provided literal value.
+ * 
+ * ```ts
+ * const parser = DPE.literal("status");
+ * const result = parser.parse("status");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: "status"
+ * }
+ * 
+ * const numberLiteral = DPE.literal(42);
+ * const numberResult = numberLiteral.parse(42);
+ * 
+ * const boolLiteral = DPE.literal(true);
+ * const boolResult = boolLiteral.parse(true);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/literal
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function literal<const GenericValue extends dataParsers.LiteralValue, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: GenericValue[];
 }>>;

package/dist/dataParser/extended/literal.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { literal as literal$1 } from '../parsers/literal.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/literal/index.md}
+ */
 function literal(value, definition) {
     const self = dataParserExtendedInit(literal$1(value, definition), {});
     return literal.overrideHandler.apply(self);

package/dist/dataParser/extended/nil.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var nil$1 = require('../parsers/nil.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/nil/index.md}
+ */
 function nil(definition) {
     const self = baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
     return nil.overrideHandler.apply(self);

package/dist/dataParser/extended/nil.d.ts

@@ -20,6 +20,34 @@ export interface DataParserNilExtended<GenericDefinition extends dataParsers.Dat
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser that accepts null.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.nil(definition?)` -> returns a nil parser
+ * 
+ * Accepts null (or the string "null" when coerce is enabled).
+ * 
+ * ```ts
+ * const parser = DPE.nil();
+ * const result = parser.parse(null);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: null
+ * }
+ * 
+ * const coerceParser = DPE.coerce.nil();
+ * const coerceResult = coerceParser.parse("null");
+ * 
+ * const nullableNil = DPE.nil().nullable();
+ * const nullableResult = nullableNil.parse(null);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/nil
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function nil<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace nil {
     var overrideHandler: import("../../common").OverrideHandler<DataParserNilExtended<dataParsers.DataParserDefinitionNil>>;

package/dist/dataParser/extended/nil.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { nil as nil$1 } from '../parsers/nil.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/nil/index.md}
+ */
 function nil(definition) {
     const self = dataParserExtendedInit(nil$1(definition), {});
     return nil.overrideHandler.apply(self);

package/dist/dataParser/extended/nullable.cjs

@@ -4,6 +4,9 @@ var baseExtended = require('../baseExtended.cjs');
 var nullable$1 = require('../parsers/nullable.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/nullable/index.md}
+ */
 function nullable(inner, definition) {
     const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
     return nullable.overrideHandler.apply(self);

package/dist/dataParser/extended/nullable.d.ts

@@ -20,6 +20,34 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended nullable parser from another parser.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.nullable(inner, definition?)` -> returns a nullable parser
+ * 
+ * Returns null (or a coalescing value) when input is null, otherwise parses with the inner parser.
+ * 
+ * ```ts
+ * const parser = DPE.nullable(DPE.string());
+ * const result = parser.parse(null);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string | null
+ * }
+ * 
+ * const withCoalescing = DPE.nullable(DPE.number(), { coalescingValue: 0 });
+ * const coalesced = withCoalescing.parse(null);
+ * 
+ * const nullableBool = DPE.nullable(DPE.boolean());
+ * const boolResult = nullableBool.parse(true);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/nullable
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;

package/dist/dataParser/extended/nullable.mjs

@@ -2,6 +2,9 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { nullable as nullable$1 } from '../parsers/nullable.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/nullable/index.md}
+ */
 function nullable(inner, definition) {
     const self = dataParserExtendedInit(nullable$1(inner, definition), {});
     return nullable.overrideHandler.apply(self);

package/dist/dataParser/extended/number.cjs

@@ -7,6 +7,9 @@ var max = require('../parsers/number/checkers/max.cjs');
 var min = require('../parsers/number/checkers/min.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/number/index.md}
+ */
 function number(definition) {
     const self = baseExtended.dataParserExtendedInit(index.number(definition), {
         min(self, min$1, definition) {
@@ -22,6 +25,9 @@ function number(definition) {
     return number.overrideHandler.apply(self);
 }
 number.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/number");
+/**
+ * {@include dataParser/extended/int/index.md}
+ */
 function int(definition) {
     return number({
         checkers: [int$1.checkerInt(definition)],