@duplojs/utils 1.4.32 → 1.4.33

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

@@ -41,6 +41,45 @@ export interface DataParserObject<GenericDefinition extends DataParserDefinition
      */
     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);

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

@@ -2,6 +2,41 @@ import { type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing, type Adaptor } from "../../../common";
 export declare function pickShape(shape: DataParserObjectShape, pickObject: Partial<Record<string, true>>): DataParserObjectShape;
+/**
+ * Creates a new object parser by selecting a subset of keys.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.pick(objectParser, pickObject, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Builds a new object parser using only the selected keys from the original shape.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * 	email: DP.string(),
+ * });
+ * 
+ * const picked = DP.pick(userParser, {
+ * 	id: true,
+ * 	name: true,
+ * });
+ * const result = picked.parse({
+ * 	id: 1,
+ * 	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 pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, pickObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Pick<GenericDataParserObject["definition"]["shape"], Adaptor<keyof GenericOmitObject, keyof GenericDataParserObject["definition"]["shape"]>>>;
 }>>;

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

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

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

@@ -15,6 +15,9 @@ var fromEntries = require('../../../object/fromEntries.cjs');
 function requiredShape(shape) {
     return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(dataParser, when.when(identifier.identifier(optional.optionalKind), (dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/required/index.md}
+ */
 function required(dataParser, definition) {
     const newShape = requiredShape(dataParser.definition.shape);
     return index.object(newShape, definition);

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

@@ -6,6 +6,43 @@ export type RequireDataParserObject<GenericShape extends DataParserObjectShape>
     [Prop in keyof GenericShape]: GenericShape[Prop] extends DataParserOptional<any> ? GenericShape[Prop]["definition"]["inner"] : GenericShape[Prop];
 }>;
 export declare function requiredShape(shape: DataParserObjectShape): DataParserObjectShape;
+/**
+ * Creates a new object parser where optional properties become required.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.required(objectParser, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Unwraps optional properties in the object shape so all keys are required.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * });
+ * 
+ * const partialUser = DP.partial(userParser);
+ * const requiredUser = DP.required(partialUser);
+ * const result = requiredUser.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id: number; name: string }
+ * }
+ * 
+ * const fromOptional = DP.required(DP.object({
+ * 	name: DP.optional(DP.string()),
+ * }));
+ * const requiredResult = fromOptional.parse({ name: "Alex" });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function required<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: RequireDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

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

@@ -13,6 +13,9 @@ import { fromEntries } from '../../../object/fromEntries.mjs';
 function requiredShape(shape) {
     return pipe(shape, entries, map(([key, dataParser]) => pipe(dataParser, when(identifier(optionalKind), (dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/required/index.md}
+ */
 function required(dataParser, definition) {
     const newShape = requiredShape(dataParser.definition.shape);
     return object(newShape, definition);

package/dist/dataParser/parsers/optional.cjs

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

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

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

package/dist/dataParser/parsers/optional.mjs

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

package/dist/dataParser/parsers/pipe.cjs

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

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

@@ -25,6 +25,37 @@ export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPi
      */
     construct<const GenericDefinition extends DataParserDefinitionPipe>(definition: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, GenericDefinition>>;
 }
+/**
+ * Creates a data parser pipeline from an input parser to an output parser.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.pipe(input, output, definition?)` -> returns a pipe parser
+ * - Curried: not available
+ * 
+ * Runs the input parser, then feeds its output to the output parser.
+ * 
+ * ```ts
+ * const schema = DP.pipe(
+ * 	DP.coerce.number(),
+ * 	DP.transform(
+ * 		DP.number(),
+ * 		(value) => value + 1,
+ * 	),
+ * );
+ * 
+ * const result = schema.parse("1234");
+ * 
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/pipe
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;
     output: GenericOutput;

package/dist/dataParser/parsers/pipe.mjs

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

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

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

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

@@ -40,6 +40,43 @@ export interface DataParserRecord<GenericDefinition extends DataParserDefinition
      */
     construct<const GenericDefinition extends DataParserDefinitionRecord>(definition: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for records with key and value parsers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.record(key, value, definition?)` -> returns a record parser
+ * - Curried: not available
+ * 
+ * Validates that the input is an object and parses each key and value with the provided parsers.
+ * 
+ * ```ts
+ * const parser = DP.record(DP.string(), DP.number());
+ * const result = parser.parse({
+ * 	aKey: 1,
+ * 	bKey: 2,
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: Record<string, number>
+ * }
+ * 
+ * const keyUnion = DP.union([DP.literal("xPos"), DP.literal("yPos")]);
+ * const strictKeys = DP.record(keyUnion, DP.boolean());
+ * const strictResult = strictKeys.parse({
+ * 	xPos: true,
+ * 	yPos: false,
+ * });
+ * 
+ * const withCheckers = DP.record(DP.string(), DP.string(), {
+ * 	checkers: [DP.checkerRefine((value) => Object.keys(value).length > 0)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/record
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;
     value: GenericDataParserValue;

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

@@ -6,6 +6,9 @@ export { findRecordRequiredKeyOnTemplateLiteralPart } from './findRecordRequired
 import { createOverride } from '../../../common/override.mjs';
 
 const recordKind = createDataParserKind("record");
+/**
+ * {@include dataParser/classic/record/index.md}
+ */
 function record(key, value, definition) {
     const self = dataParserInit(recordKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/recover.cjs

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

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

@@ -25,6 +25,36 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
      */
     construct<const GenericDefinition extends DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that recovers with a fallback value on error.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.recover(inner, recoveredValue, definition?)` -> returns a recover parser
+ * - Curried: not available
+ * 
+ * Runs the inner parser and returns the recovered value when parsing fails.
+ * 
+ * ```ts
+ * const parser = DP.recover(DP.number(), 0);
+ * const result = parser.parse("not-a-number");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const withString = DP.recover(DP.string(), "fallback");
+ * const stringResult = withString.parse(123);
+ * 
+ * const withCheckers = DP.recover(DP.string(), "fallback", {
+ * 	checkers: [DP.checkerRefine((value) => value.length > 0)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/recover
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;

package/dist/dataParser/parsers/recover.mjs

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

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

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