@duplojs/utils 1.4.32 → 1.4.34

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

@@ -12,14 +12,36 @@ export interface DataParserBooleanExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserBooleanCheckers,
         ...dataParsers.DataParserBooleanCheckers[]
     ], GenericChecker>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBooleanExtended<MergeDefinition<dataParsers.DataParserDefinitionBoolean, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserBooleanExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -13,14 +13,36 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserDateCheckers,
         ...dataParsers.DataParserDateCheckers[]
     ], GenericChecker>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionDate>(definition: GenericDefinition): DataParserDateExtended<MergeDefinition<dataParsers.DataParserDefinitionDate, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -12,14 +12,35 @@ export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserEmptyCheckers,
         ...dataParsers.DataParserEmptyCheckers[]
     ], GenericChecker>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserEmptyExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -12,14 +12,46 @@ export interface DataParserLazyExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserLazyCheckers<Output<this>>,
         ...dataParsers.DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLazyExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -12,14 +12,36 @@ export interface DataParserLiteralExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserLiteralCheckers<Output<this>>,
         ...dataParsers.DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserLiteralExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -12,14 +12,36 @@ export interface DataParserNilExtended<GenericDefinition extends dataParsers.Dat
         dataParsers.DataParserNilCheckers,
         ...dataParsers.DataParserNilCheckers[]
     ], GenericChecker>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionNil>(definition: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNilExtended<AddCheckersToDefinition<GenericDefinition, readonly [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

@@ -12,14 +12,36 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
         dataParsers.DataParserNullableCheckers<Output<this>>,
         ...dataParsers.DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, readonly [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)],