@duplojs/utils 1.4.32 → 1.4.34

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

@@ -19,11 +19,46 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
         DataParserLazyCheckers<Output<this>>,
         ...DataParserLazyCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    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

@@ -20,11 +20,36 @@ export interface DataParserLiteral<GenericDefinition extends DataParserDefinitio
         DataParserLiteralCheckers<Output<this>>,
         ...DataParserLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    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

@@ -19,11 +19,37 @@ export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil
         DataParserNilCheckers,
         ...DataParserNilCheckers[]
     ], GenericChecker>): DataParserNil<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    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

@@ -20,11 +20,37 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
         DataParserNullableCheckers<Output<this>>,
         ...DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullable<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    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

@@ -21,11 +21,37 @@ export interface DataParserNumber<GenericDefinition extends DataParserDefinition
         DataParserNumberCheckers,
         ...DataParserNumberCheckers[]
     ], GenericChecker>): DataParserNumber<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    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);

package/dist/dataParser/parsers/object/extends.d.ts

@@ -3,6 +3,56 @@ import { type DataParserObjectShape, type DataParserDefinitionObject, type DataP
 import { type NeverCoalescing } from "../../../common";
 import { type AssignObjects } from "../../../object";
 export declare function extendsShape(shape: DataParserObjectShape, extension: DataParserObjectShape): DataParserObjectShape;
+/**
+ * Creates a new object parser by extending the shape with additional properties.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.extends(objectParser, extension, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Builds a new object parser by merging the existing shape with the extension.
+ * 
+ * ```ts
+ * const base = DP.object({
+ * 	id: DP.number(),
+ * });
+ * 
+ * const extended = DP.extends(base, {
+ * 	name: DP.string(),
+ * });
+ * 
+ * const result = extended.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id: number; name: string }
+ * }
+ * 
+ * const withMore = DP.extends(base, {
+ * 	active: DP.boolean(),
+ * });
+ * const withMoreResult = withMore.parse({
+ * 	id: 2,
+ * 	active: true,
+ * });
+ * 
+ * const nested = DP.extends(
+ * 	DP.object({ id: DP.number() }),
+ * 	{ meta: DP.object({ tag: DP.string() }) },
+ * );
+ * const nestedResult = nested.parse({
+ * 	id: 3,
+ * 	meta: { tag: "dev" },
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 declare function extend<GenericDataParserObject extends DataParserObject, const GenericExtension extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, extension: GenericExtension, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: AssignObjects<GenericDataParserObject["definition"]["shape"], GenericExtension>;
 }>>;

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

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

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

@@ -12,6 +12,9 @@ var forward = require('../../../common/forward.cjs');
 var override = require('../../../common/override.cjs');
 
 const objectKind = kind.createDataParserKind("object");
+/**
+ * {@include dataParser/classic/object/index.md}
+ */
 function object(shape, definition) {
     const self = base.dataParserInit(objectKind, {
         shape,

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

@@ -36,11 +36,46 @@ export interface DataParserObject<GenericDefinition extends DataParserDefinition
         DataParserObjectCheckers<Output<this>>,
         ...DataParserObjectCheckers<Output<this>>[]
     ], GenericChecker>): DataParserObject<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionObject>(definition: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for objects with a defined shape.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.object(shape, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Validates that the input is an object and parses each property in the provided shape.
+ * 
+ * ```ts
+ * const parser = DP.object({
+ * 	name: DP.string(),
+ * 	age: DP.number(),
+ * });
+ * const result = parser.parse({
+ * 	name: "Alex",
+ * 	age: 32,
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { name: string; age: number }
+ * }
+ * 
+ * const partialUser = DP.partial(parser);
+ * const partialResult = partialUser.parse({ name: "Alex" });
+ * // value: { name?: string | undefined }
+ * 
+ * const requiredUser = DP.required(partialUser);
+ * const requiredResult = requiredUser.parse({
+ * 	name: "Alex",
+ * 	age: 32,
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: GenericShape;
 }>>;

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

@@ -10,6 +10,9 @@ import { forward } from '../../../common/forward.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const objectKind = createDataParserKind("object");
+/**
+ * {@include dataParser/classic/object/index.md}
+ */
 function object(shape, definition) {
     const self = dataParserInit(objectKind, {
         shape,

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

@@ -10,6 +10,9 @@ var fromEntries = require('../../../object/fromEntries.cjs');
 function omitShape(shape, omitObject) {
     return pipe.pipe(shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/omit/index.md}
+ */
 function omit(dataParser, omitObject, definition) {
     const newShape = omitShape(dataParser.definition.shape, omitObject);
     return index.object(newShape, definition);

package/dist/dataParser/parsers/object/omit.d.ts

@@ -2,6 +2,44 @@ import { type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing } from "../../../common";
 export declare function omitShape(shape: DataParserObjectShape, omitObject: Partial<Record<string, true>>): DataParserObjectShape;
+/**
+ * Creates a new object parser by omitting keys from a shape.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.omit(objectParser, omitObject, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Builds a new object parser without the omitted keys from the original shape.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * 	email: DP.string(),
+ * });
+ * 
+ * const withoutEmail = DP.omit(userParser, { email: true });
+ * const result = withoutEmail.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id: number; name: string }
+ * }
+ * 
+ * const omitMultiple = DP.omit(userParser, {
+ * 	id: true,
+ * 	email: true,
+ * });
+ * const omitResult = omitMultiple.parse({ name: "Alex" });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function omit<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Omit<GenericDataParserObject["definition"]["shape"], keyof GenericOmitObject>>;
 }>>;

package/dist/dataParser/parsers/object/omit.mjs

@@ -8,6 +8,9 @@ import { fromEntries } from '../../../object/fromEntries.mjs';
 function omitShape(shape, omitObject) {
     return pipe(shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/omit/index.md}
+ */
 function omit(dataParser, omitObject, definition) {
     const newShape = omitShape(dataParser.definition.shape, omitObject);
     return object(newShape, definition);

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

@@ -13,6 +13,9 @@ var fromEntries = require('../../../object/fromEntries.cjs');
 function partialShape(shape) {
     return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(dataParser, whenNot.whenNot(identifier.identifier(optional.optionalKind), optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/partial/index.md}
+ */
 function partial(dataParser, definition) {
     const newShape = partialShape(dataParser.definition.shape);
     return index.object(newShape, definition);

package/dist/dataParser/parsers/object/partial.d.ts

@@ -10,6 +10,34 @@ export type PartialDataParserObject<GenericShape extends DataParserObjectShape>
     }>;
 }>;
 export declare function partialShape(shape: DataParserObjectShape): DataParserObjectShape;
+/**
+ * Creates a new object parser where all properties become optional.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.partial(objectParser, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Wraps each property of the object shape in optional(), allowing missing keys.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * });
+ * 
+ * const partialUser = DP.partial(userParser);
+ * const result = partialUser.parse({ name: "Alex" });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id?: number; name?: string }
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function partial<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: PartialDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

package/dist/dataParser/parsers/object/partial.mjs

@@ -11,6 +11,9 @@ import { fromEntries } from '../../../object/fromEntries.mjs';
 function partialShape(shape) {
     return pipe(shape, entries, map(([key, dataParser]) => pipe(dataParser, whenNot(identifier(optionalKind), optional), (dataParser) => entry(key, dataParser))), fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/partial/index.md}
+ */
 function partial(dataParser, definition) {
     const newShape = partialShape(dataParser.definition.shape);
     return object(newShape, definition);

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

@@ -10,6 +10,9 @@ var fromEntries = require('../../../object/fromEntries.cjs');
 function pickShape(shape, pickObject) {
     return pipe.pipe(shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, pickObject)), fromEntries.fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/pick/index.md}
+ */
 function pick(dataParser, pickObject, definition) {
     const newShape = pickShape(dataParser.definition.shape, pickObject);
     return index.object(newShape, definition);