@duplojs/utils 1.4.32 → 1.4.33

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

@@ -20,6 +20,32 @@ export interface DataParserUnknownExtended<GenericDefinition extends dataParsers
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser that accepts any value.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.unknown(definition?)` -> returns an unknown parser
+ * 
+ * Always succeeds, returning the input value as unknown.
+ * 
+ * ```ts
+ * const parser = DPE.unknown();
+ * const result = parser.parse({ any: "value" });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: unknown
+ * }
+ * 
+ * const numberResult = parser.parse(123);
+ * 
+ * const nullResult = parser.parse(null);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/unknown
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function unknown<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknownExtended<MergeDefinition<dataParsers.DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace unknown {
     var overrideHandler: import("../../common").OverrideHandler<DataParserUnknownExtended<dataParsers.DataParserDefinitionUnknown>>;

package/dist/dataParser/extended/unknown.mjs

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

package/dist/dataParser/parsers/array/index.cjs

@@ -6,6 +6,9 @@ var kind = require('../../kind.cjs');
 var override = require('../../../common/override.cjs');
 
 const arrayKind = kind.createDataParserKind("array");
+/**
+ * {@include dataParser/classic/array/index.md}
+ */
 function array(element, definition) {
     const self = base.dataParserInit(arrayKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/array/index.d.ts

@@ -26,6 +26,36 @@ export interface DataParserArray<GenericDefinition extends DataParserDefinitionA
      */
     construct<const GenericDefinition extends DataParserDefinitionArray>(definition: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for arrays of a given element parser.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.array(element, definition?)` -> returns an array parser
+ * - Curried: not available
+ * 
+ * Validates that the input is an array and validates each element with the provided parser.
+ * 
+ * ```ts
+ * const parser = DP.array(DP.string());
+ * const result = parser.parse(["a", "b"]);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string[]
+ * }
+ * 
+ * const withCheckers = DP.array(DP.number(), {
+ * 	checkers: [DP.checkerArrayMin(1), DP.checkerArrayMax(3)],
+ * });
+ * 
+ * const nested = DP.array(DP.array(DP.boolean()));
+ * const nestedResult = nested.parse([[true, false]]);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/array
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
     element: GenericElement;
 }>>;

package/dist/dataParser/parsers/array/index.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../kind.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const arrayKind = createDataParserKind("array");
+/**
+ * {@include dataParser/classic/array/index.md}
+ */
 function array(element, definition) {
     const self = dataParserInit(arrayKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/bigint/index.cjs

@@ -6,6 +6,9 @@ var kind = require('../../kind.cjs');
 var override = require('../../../common/override.cjs');
 
 const bigIntKind = kind.createDataParserKind("bigint");
+/**
+ * {@include dataParser/classic/bigint/index.md}
+ */
 function bigint(definition) {
     const self = base.dataParserInit(bigIntKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/bigint/index.d.ts

@@ -26,6 +26,36 @@ export interface DataParserBigInt<GenericDefinition extends DataParserDefinition
      */
     construct<const GenericDefinition extends DataParserDefinitionBigInt>(definition: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for bigint values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.bigint(definition?)` -> returns a bigint parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a bigint, optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.bigint();
+ * const result = parser.parse(BigInt(42));
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: bigint
+ * }
+ * 
+ * const withCheckers = DP.bigint({
+ * 	checkers: [DP.checkerBigIntMin(BigInt(1)), DP.checkerBigIntMax(BigInt(10))],
+ * });
+ * 
+ * const coerceParser = DP.coerce.bigint();
+ * const coerceResult = coerceParser.parse("42");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/bigint
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function bigint<const GenericDefinition extends Partial<DataParserDefinitionBigInt> = never>(definition?: GenericDefinition): DataParserBigInt<MergeDefinition<DataParserDefinitionBigInt, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace bigint {
     var overrideHandler: import("../../../common").OverrideHandler<DataParserBigInt<DataParserDefinitionBigInt>>;

package/dist/dataParser/parsers/bigint/index.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../kind.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const bigIntKind = createDataParserKind("bigint");
+/**
+ * {@include dataParser/classic/bigint/index.md}
+ */
 function bigint(definition) {
     const self = dataParserInit(bigIntKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/boolean.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const booleanKind = kind.createDataParserKind("boolean");
+/**
+ * {@include dataParser/classic/boolean/index.md}
+ */
 function boolean(definition) {
     const self = base.dataParserInit(booleanKind, {
         errorMessage: definition?.errorMessage,

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

@@ -24,6 +24,36 @@ export interface DataParserBoolean<GenericDefinition extends DataParserDefinitio
      */
     construct<const GenericDefinition extends DataParserDefinitionBoolean>(definition: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for boolean values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.boolean(definition?)` -> returns a boolean parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a boolean, optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.boolean();
+ * const result = parser.parse(true);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: boolean
+ * }
+ * 
+ * const onlyTrue = DP.boolean({
+ * 	checkers: [DP.checkerRefine((value) => value === true)],
+ * });
+ * 
+ * const coerceParser = DP.coerce.boolean();
+ * const coerceResult = coerceParser.parse("false");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/boolean
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function boolean<const GenericDefinition extends Partial<DataParserDefinitionBoolean> = never>(definition?: GenericDefinition): DataParserBoolean<MergeDefinition<DataParserDefinitionBoolean, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace boolean {
     var overrideHandler: import("../../common").OverrideHandler<DataParserBoolean<DataParserDefinitionBoolean>>;

package/dist/dataParser/parsers/boolean.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const booleanKind = createDataParserKind("boolean");
+/**
+ * {@include dataParser/classic/boolean/index.md}
+ */
 function boolean(definition) {
     const self = dataParserInit(booleanKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/date.cjs

@@ -9,6 +9,9 @@ var is = require('../../date/is.cjs');
 var override = require('../../common/override.cjs');
 
 const dateKind = kind.createDataParserKind("date");
+/**
+ * {@include dataParser/classic/date/index.md}
+ */
 function date(definition) {
     const self = base.dataParserInit(dateKind, {
         errorMessage: definition?.errorMessage,

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

@@ -25,6 +25,36 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
      */
     construct<const GenericDefinition extends DataParserDefinitionDate>(definition: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for TheDate values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.date(definition?)` -> returns a date parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a TheDate, optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.date();
+ * const result = parser.parse("date0+");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: TheDate
+ * }
+ * 
+ * const withCheckers = DP.date({
+ * 	checkers: [DP.checkerRefine((value) => value !== "date0+")],
+ * });
+ * 
+ * const coerceParser = DP.coerce.date();
+ * const coerceResult = coerceParser.parse("2024-01-01T00:00:00.000Z");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/date
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function date<const GenericDefinition extends Partial<DataParserDefinitionDate> = never>(definition?: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace date {
     var overrideHandler: import("../../common").OverrideHandler<DataParserDate<DataParserDefinitionDate>>;

package/dist/dataParser/parsers/date.mjs

@@ -7,6 +7,9 @@ import { is } from '../../date/is.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const dateKind = createDataParserKind("date");
+/**
+ * {@include dataParser/classic/date/index.md}
+ */
 function date(definition) {
     const self = dataParserInit(dateKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/empty.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const emptyKind = kind.createDataParserKind("empty");
+/**
+ * {@include dataParser/classic/empty/index.md}
+ */
 function empty(definition) {
     const self = base.dataParserInit(emptyKind, {
         errorMessage: definition?.errorMessage,

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

@@ -24,6 +24,35 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
      */
     construct<const GenericDefinition extends DataParserDefinitionEmpty>(definition: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts undefined.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.empty(definition?)` -> returns an empty parser
+ * - Curried: not available
+ * 
+ * Accepts undefined (or the string "undefined" when coerce is enabled) and rejects other inputs.
+ * 
+ * ```ts
+ * const parser = DP.empty();
+ * const result = parser.parse(undefined);
+ * if (E.isRight(result)) {
+ * 	// E.EitherSuccess<undefined>
+ * }
+ * 
+ * const withCheckers = DP.empty({
+ * 	checkers: [DP.checkerRefine((value) => value === undefined)],
+ * });
+ * 
+ * const coerceParser = DP.coerce.empty();
+ * const coerceResult = coerceParser.parse("undefined");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/empty
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace empty {
     var overrideHandler: import("../../common").OverrideHandler<DataParserEmpty<DataParserDefinitionEmpty>>;

package/dist/dataParser/parsers/empty.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const emptyKind = createDataParserKind("empty");
+/**
+ * {@include dataParser/classic/empty/index.md}
+ */
 function empty(definition) {
     const self = dataParserInit(emptyKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/lazy.cjs

@@ -6,6 +6,9 @@ var memo = require('../../common/memo.cjs');
 var override = require('../../common/override.cjs');
 
 const lazyKind = kind.createDataParserKind("lazy");
+/**
+ * {@include dataParser/classic/lazy/index.md}
+ */
 function lazy(getter, definition) {
     const self = base.dataParserInit(lazyKind, {
         errorMessage: definition?.errorMessage,

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

@@ -24,6 +24,45 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
      */
     construct<const GenericDefinition extends DataParserDefinitionLazy>(definition: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, GenericDefinition>>;
 }
+/**
+ * Creates a lazy data parser resolved at runtime.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.lazy(getter, definition?)` -> returns a lazy parser
+ * - Curried: not available
+ * 
+ * Defers parser creation until execution, useful for recursive schemas.
+ * 
+ * ```ts
+ * const parser = DP.lazy(() => DP.string());
+ * const result = parser.parse("lazy");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * interface RecursiveSchema {
+ * 	value: number;
+ * 	next?: RecursiveSchema;
+ * }
+ * 
+ * const recursive: DP.Contract<RecursiveSchema> = DP.lazy(
+ * 	() => DP.object({
+ * 		value: DP.number(),
+ * 		next: DP.optional(recursive),
+ * 	}),
+ * );
+ * const recursiveResult = recursive.parse({
+ * 	value: 1,
+ * 	next: { value: 2 },
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/lazy
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter: Memoized<GenericDataParser>;
 }>>;

package/dist/dataParser/parsers/lazy.mjs

@@ -4,6 +4,9 @@ import { memo } from '../../common/memo.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const lazyKind = createDataParserKind("lazy");
+/**
+ * {@include dataParser/classic/lazy/index.md}
+ */
 function lazy(getter, definition) {
     const self = dataParserInit(lazyKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/literal.cjs

@@ -7,6 +7,9 @@ var coalescing = require('../../array/coalescing.cjs');
 var override = require('../../common/override.cjs');
 
 const literalKind = kind.createDataParserKind("literal");
+/**
+ * {@include dataParser/classic/literal/index.md}
+ */
 function literal(value, definition) {
     const self = base.dataParserInit(literalKind, {
         errorMessage: definition?.errorMessage,

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

@@ -25,6 +25,35 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
      */
     construct<const GenericDefinition extends DataParserDefinitionLiteral>(definition: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for a literal value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.literal(value)` -> returns a literal parser
+ * - Curried: not available
+ * 
+ * Accepts only the provided literal value and rejects any other input.
+ * 
+ * ```ts
+ * const parser = DP.literal("status");
+ * const result = parser.parse("status");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: "status"
+ * }
+ * 
+ * const numberLiteral = DP.literal(42);
+ * const numberResult = numberLiteral.parse(42);
+ * 
+ * const boolLiteral = DP.literal(true);
+ * const boolResult = boolLiteral.parse(true);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/literal
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | readonly GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
     value: readonly GenericValue[];
 }>>;

package/dist/dataParser/parsers/literal.mjs

@@ -5,6 +5,9 @@ import { coalescing } from '../../array/coalescing.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const literalKind = createDataParserKind("literal");
+/**
+ * {@include dataParser/classic/literal/index.md}
+ */
 function literal(value, definition) {
     const self = dataParserInit(literalKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/nil.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const nilKind = kind.createDataParserKind("nil");
+/**
+ * {@include dataParser/classic/nil/index.md}
+ */
 function nil(definition) {
     const self = base.dataParserInit(nilKind, {
         errorMessage: definition?.errorMessage,

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

@@ -24,6 +24,36 @@ export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil
      */
     construct<const GenericDefinition extends DataParserDefinitionNil>(definition: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts null.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.nil(definition?)` -> returns a nil parser
+ * - Curried: not available
+ * 
+ * Accepts null (or the string "null" when coerce is enabled) and rejects other inputs.
+ * 
+ * ```ts
+ * const parser = DP.nil();
+ * const result = parser.parse(null);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: null
+ * }
+ * 
+ * const withCheckers = DP.nil({
+ * 	checkers: [DP.checkerRefine((value) => value === null)],
+ * });
+ * 
+ * const coerceParser = DP.coerce.nil();
+ * const coerceResult = coerceParser.parse("null");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/nil
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function nil<const GenericDefinition extends Partial<DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace nil {
     var overrideHandler: import("../../common").OverrideHandler<DataParserNil<DataParserDefinitionNil>>;

package/dist/dataParser/parsers/nil.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const nilKind = createDataParserKind("nil");
+/**
+ * {@include dataParser/classic/nil/index.md}
+ */
 function nil(definition) {
     const self = dataParserInit(nilKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/nullable.cjs

@@ -5,6 +5,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const nullableKind = kind.createDataParserKind("nullable");
+/**
+ * {@include dataParser/classic/nullable/index.md}
+ */
 function nullable(inner, definition) {
     const self = base.dataParserInit(nullableKind, {
         errorMessage: definition?.errorMessage,

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

@@ -25,6 +25,36 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
      */
     construct<const GenericDefinition extends DataParserDefinitionNullable>(definition: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts null or the inner parser output.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.nullable(inner, definition?)` -> returns a nullable parser
+ * - Curried: not available
+ * 
+ * Returns null (or a coalescing value) when input is null, otherwise parses with the inner parser.
+ * 
+ * ```ts
+ * const parser = DP.nullable(DP.string());
+ * const result = parser.parse(null);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string | null
+ * }
+ * 
+ * const withCoalescing = DP.nullable(DP.number(), { coalescingValue: 0 });
+ * const coalesced = withCoalescing.parse(null);
+ * 
+ * const withCheckers = DP.nullable(DP.boolean(), {
+ * 	checkers: [DP.checkerRefine((value) => value !== null)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/nullable
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;

package/dist/dataParser/parsers/nullable.mjs

@@ -3,6 +3,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const nullableKind = createDataParserKind("nullable");
+/**
+ * {@include dataParser/classic/nullable/index.md}
+ */
 function nullable(inner, definition) {
     const self = dataParserInit(nullableKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/number/index.cjs

@@ -6,6 +6,9 @@ var kind = require('../../kind.cjs');
 var override = require('../../../common/override.cjs');
 
 const numberKind = kind.createDataParserKind("number");
+/**
+ * {@include dataParser/classic/number/index.md}
+ */
 function number(definition) {
     const self = base.dataParserInit(numberKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/number/index.d.ts

@@ -26,6 +26,36 @@ export interface DataParserNumber<GenericDefinition extends DataParserDefinition
      */
     construct<const GenericDefinition extends DataParserDefinitionNumber>(definition: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for numbers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.number(definition?)` -> returns a number parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a number (non-NaN), optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.number();
+ * const result = parser.parse(42);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const withCheckers = DP.number({
+ * 	checkers: [DP.checkerNumberMin(0), DP.checkerInt()],
+ * });
+ * 
+ * const coerceParser = DP.coerce.number();
+ * const coerceResult = coerceParser.parse("42");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function number<const GenericDefinition extends Partial<DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumber<MergeDefinition<DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace number {
     var overrideHandler: import("../../../common").OverrideHandler<DataParserNumber<DataParserDefinitionNumber>>;

package/dist/dataParser/parsers/number/index.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../kind.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const numberKind = createDataParserKind("number");
+/**
+ * {@include dataParser/classic/number/index.md}
+ */
 function number(definition) {
     const self = dataParserInit(numberKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/object/extends.cjs

@@ -6,6 +6,9 @@ var assign = require('../../../object/assign.cjs');
 function extendsShape(shape, extension) {
     return assign.assign(shape, extension);
 }
+/**
+ * {@include dataParser/classic/object/extends/index.md}
+ */
 function extend(dataParser, extension, definition) {
     const newShape = extendsShape(dataParser.definition.shape, extension);
     return index.object(newShape, definition);