@duplojs/utils 1.4.32 → 1.4.33

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

@@ -19,20 +19,163 @@ export interface DataParserNumberExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * Adds a minimum value checker to a number parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns a number parser
+     * 
+     * Ensures the number is at least the given minimum.
+     * 
+     * ```ts
+     * const parser = DPE.number().min(0);
+     * const result = parser.parse(3);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: number
+     * }
+     * 
+     * const withMessage = DPE.number().min(10, { errorMessage: "number.too-small" });
+     * const messageResult = withMessage.parse(10);
+     * 
+     * const chained = DPE.number().min(1).max(5);
+     * const chainedResult = chained.parse(3);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+     * 
+     * @namespace DPE
+     * 
+     */
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMin, "min">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerNumberMin
     ]>>;
+    /**
+     * Adds a maximum value checker to a number parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns a number parser
+     * 
+     * Ensures the number is at most the given maximum.
+     * 
+     * ```ts
+     * const parser = DPE.number().max(10);
+     * const result = parser.parse(5);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: number
+     * }
+     * 
+     * const withMessage = DPE.number().max(100, { errorMessage: "number.too-large" });
+     * const messageResult = withMessage.parse(100);
+     * 
+     * const chained = DPE.number().min(1).max(5);
+     * const chainedResult = chained.parse(2);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+     * 
+     * @namespace DPE
+     * 
+     */
     max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMax, "max">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerNumberMax
     ]>>;
+    /**
+     * Adds an integer checker to a number parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.int(definition?)` -> returns a number parser
+     * 
+     * Ensures the number is an integer.
+     * 
+     * ```ts
+     * const parser = DPE.number().int();
+     * const result = parser.parse(4);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: number
+     * }
+     * 
+     * const withMessage = DPE.number().int({ errorMessage: "number.not-int" });
+     * const messageResult = withMessage.parse(10);
+     * 
+     * const chained = DPE.number().min(0).int();
+     * const chainedResult = chained.parse(3);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+     * 
+     * @namespace DPE
+     * 
+     */
     int(definition?: Partial<dataParsers.DataParserCheckerDefinitionInt>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.DataParserCheckerInt
     ]>>;
 }
+/**
+ * Creates an extended data parser for numbers.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.number(definition?)` -> returns a number parser
+ * 
+ * Validates numbers and exposes number-specific methods like min, max, and int.
+ * 
+ * ```ts
+ * const parser = DPE.number()
+ * 	.min(0)
+ * 	.max(10)
+ * 	.int();
+ * const result = parser.parse(5);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const coerceParser = DPE.coerce.number();
+ * const coerceResult = coerceParser.parse("42");
+ * 
+ * const intOnly = DPE.number().int();
+ * const intResult = intOnly.parse(3);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function number<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace number {
     var overrideHandler: import("../../common").OverrideHandler<DataParserNumberExtended<dataParsers.DataParserDefinitionNumber>>;
 }
+/**
+ * Creates an extended data parser for integers.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.int(definition?)` -> returns an int parser
+ * 
+ * Validates that the input is an integer number.
+ * 
+ * ```ts
+ * const parser = DPE.int();
+ * const result = parser.parse(10);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const withMessage = DPE.int({ errorMessage: "number.not-int" });
+ * const messageResult = withMessage.parse(5);
+ * 
+ * const withRange = DPE.int().min(0).max(10);
+ * const rangeResult = withRange.parse(3);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/number
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function int(definition?: Partial<dataParsers.DataParserCheckerDefinitionInt>): DataParserNumberExtended<{
     readonly checkers: readonly [dataParsers.DataParserCheckerInt];
     readonly errorMessage?: string | undefined;

package/dist/dataParser/extended/number.mjs

@@ -5,6 +5,9 @@ import { checkerNumberMax } from '../parsers/number/checkers/max.mjs';
 import { checkerNumberMin } from '../parsers/number/checkers/min.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/number/index.md}
+ */
 function number(definition) {
     const self = dataParserExtendedInit(number$1(definition), {
         min(self, min, definition) {
@@ -20,6 +23,9 @@ function number(definition) {
     return number.overrideHandler.apply(self);
 }
 number.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/number");
+/**
+ * {@include dataParser/extended/int/index.md}
+ */
 function int(definition) {
     return number({
         checkers: [checkerInt(definition)],

package/dist/dataParser/extended/object.cjs

@@ -9,6 +9,9 @@ var pick = require('../parsers/object/pick.cjs');
 var omit = require('../parsers/object/omit.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/object/index.md}
+ */
 function object(shape, definition) {
     const self = baseExtended.dataParserExtendedInit(index.object(shape, definition), {
         omit: (self, omitObject, definition) => {

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

@@ -20,22 +20,265 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * Creates a new object parser by omitting keys from the current shape.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.omit(omitObject, definition?)` -> returns an object parser
+     * 
+     * Builds a new object parser without the omitted keys.
+     * 
+     * ```ts
+     * const parser = DPE.object({
+     * 	id: DPE.number(),
+     * 	name: DPE.string(),
+     * 	email: DPE.string(),
+     * });
+     * 
+     * const omitted = parser.omit({ email: true });
+     * const result = omitted.parse({
+     * 	id: 1,
+     * 	name: "Alex",
+     * });
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: { id: number; name: string }
+     * }
+     * 
+     * const omitId = parser.omit({ id: true });
+     * const omitIdResult = omitId.parse({
+     * 	name: "Alex",
+     * 	email: "a@b.com",
+     * });
+     * 
+     * const omitName = parser.omit({ name: true });
+     * const omitNameResult = omitName.parse({
+     * 	id: 1,
+     * 	email: "a@b.com",
+     * });
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+     * 
+     * @namespace DPE
+     * 
+     */
     omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: SimplifyTopLevel<Omit<GenericDefinition["shape"], keyof GenericOmitObject>>;
     }>>;
+    /**
+     * Creates a new object parser by selecting keys from the current shape.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.pick(pickObject, definition?)` -> returns an object parser
+     * 
+     * Builds a new object parser using only the selected keys.
+     * 
+     * ```ts
+     * const parser = DPE.object({
+     * 	id: DPE.number(),
+     * 	name: DPE.string(),
+     * 	email: DPE.string(),
+     * });
+     * 
+     * const picked = parser.pick({
+     * 	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 }
+     * }
+     * 
+     * const pickEmail = parser.pick({ email: true });
+     * const emailResult = pickEmail.parse({ email: "a@b.com" });
+     * 
+     * const pickId = parser.pick({ id: true });
+     * const idResult = pickId.parse({ id: 1 });
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+     * 
+     * @namespace DPE
+     * 
+     */
     pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: SimplifyTopLevel<Pick<GenericDefinition["shape"], Adaptor<keyof GenericPickObject, keyof GenericDefinition["shape"]>>>;
     }>>;
+    /**
+     * Extends an object parser with additional properties.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.extends(extension, definition?)` -> returns an object parser
+     * 
+     * Merges the current object shape with the extension and returns a new parser.
+     * 
+     * ```ts
+     * const base = DPE.object({
+     * 	id: DPE.number(),
+     * });
+     * 
+     * const extended = base.extends({
+     * 	name: DPE.string(),
+     * });
+     * 
+     * const result = extended.parse({
+     * 	id: 1,
+     * 	name: "Alex",
+     * });
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: { id: number; name: string }
+     * }
+     * 
+     * const withMore = base.extends({
+     * 	active: DPE.boolean(),
+     * });
+     * const withMoreResult = withMore.parse({
+     * 	id: 2,
+     * 	active: true,
+     * });
+     * 
+     * const chained = DPE.object({ id: DPE.number() })
+     * 	.extends({ name: DPE.string() })
+     * 	.partial();
+     * const chainedResult = chained.parse({});
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+     * 
+     * @namespace DPE
+     * 
+     */
     extends<const GenericExtension extends dataParsers.DataParserObjectShape, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(extension: GenericExtension, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: AssignObjects<GenericDefinition["shape"], GenericExtension>;
     }>>;
+    /**
+     * Makes all object properties optional.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.partial(definition?)` -> returns an object parser
+     * 
+     * Wraps each property of the object shape in optional().
+     * 
+     * ```ts
+     * const parser = DPE.object({
+     * 	id: DPE.number(),
+     * 	name: DPE.string(),
+     * });
+     * 
+     * const partialUser = parser.partial();
+     * const result = partialUser.parse({ name: "Alex" });
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: { id?: number; name?: string }
+     * }
+     * 
+     * const emptyUser = partialUser.parse({});
+     * 
+     * const nested = DPE.object({ profile: parser }).partial();
+     * const nestedResult = nested.parse({});
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+     * 
+     * @namespace DPE
+     * 
+     */
     partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: dataParsers.PartialDataParserObject<GenericDefinition["shape"]>;
     }>>;
+    /**
+     * Makes optional object properties required.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.required(definition?)` -> returns an object parser
+     * 
+     * Unwraps optional properties so all keys are required.
+     * 
+     * ```ts
+     * const parser = DPE.object({
+     * 	id: DPE.number(),
+     * 	name: DPE.string(),
+     * });
+     * 
+     * const partialUser = parser.partial();
+     * const requiredUser = partialUser.required();
+     * const result = requiredUser.parse({
+     * 	id: 1,
+     * 	name: "Alex",
+     * });
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: { id: number; name: string }
+     * }
+     * 
+     * const fromOptional = DPE.object({ name: DPE.optional(DPE.string()) }).required();
+     * const optionalResult = fromOptional.parse({ name: "Alex" });
+     * 
+     * const strict = parser.required();
+     * const strictResult = strict.parse({
+     * 	id: 1,
+     * 	name: "Alex",
+     * });
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+     * 
+     * @namespace DPE
+     * 
+     */
     required<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: dataParsers.RequireDataParserObject<GenericDefinition["shape"]>;
     }>>;
 }
+/**
+ * Creates an extended data parser for objects with a defined shape.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.object(shape, definition?)` -> returns an object parser
+ * 
+ * Validates objects and exposes object-specific helpers like pick, omit, partial, and required.
+ * 
+ * ```ts
+ * const userParser = DPE.object({
+ * 	id: DPE.number(),
+ * 	name: DPE.string(),
+ * 	email: DPE.string(),
+ * });
+ * 
+ * const picked = userParser.pick({
+ * 	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 }
+ * }
+ * 
+ * const omitted = userParser.omit({ email: true });
+ * const omitResult = omitted.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * 
+ * const partialUser = userParser.partial();
+ * const partialResult = partialUser.parse({ name: "Alex" });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function object<const GenericShape extends dataParsers.DataParserObjectShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;
 }>>;

package/dist/dataParser/extended/object.mjs

@@ -7,6 +7,9 @@ import { pickShape } from '../parsers/object/pick.mjs';
 import { omitShape } from '../parsers/object/omit.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/object/index.md}
+ */
 function object(shape, definition) {
     const self = dataParserExtendedInit(object$1(shape, definition), {
         omit: (self, omitObject, definition) => {

package/dist/dataParser/extended/optional.cjs

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

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

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

package/dist/dataParser/extended/optional.mjs

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

package/dist/dataParser/extended/pipe.cjs

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

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

@@ -20,6 +20,34 @@ export interface DataParserPipeExtended<GenericDefinition extends dataParsers.Da
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended pipe parser from two parsers.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.pipe(input, output, definition?)` -> returns a pipe parser
+ * 
+ * Runs the input parser, then feeds its output to the output parser.
+ * 
+ * ```ts
+ * const parser = DPE.pipe(DPE.string(), DPE.coerce.number());
+ * const result = parser.parse("42");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const toLength = DPE.pipe(DPE.string(), DPE.transform(DPE.string(), (value) => value.length));
+ * const lengthResult = toLength.parse("Duplo");
+ * 
+ * const passThrough = DPE.pipe(DPE.number(), DPE.number());
+ * const passResult = passThrough.parse(10);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/pipe
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;
     output: GenericOutput;

package/dist/dataParser/extended/pipe.mjs

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

package/dist/dataParser/extended/record.cjs

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

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

@@ -20,6 +20,44 @@ export interface DataParserRecordExtended<GenericDefinition extends dataParsers.
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser for records with key and value parsers.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.record(key, value, definition?)` -> returns a record parser
+ * 
+ * Validates objects by parsing each key and value with the provided parsers.
+ * 
+ * ```ts
+ * const parser = DPE.record(DPE.string(), DPE.number());
+ * const result = parser.parse({
+ * 	aKey: 1,
+ * 	bKey: 2,
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: Partial<Record<string, number>>
+ * }
+ * 
+ * const keyUnion = DPE.union([DPE.literal("xPos"), DPE.literal("yPos")]);
+ * const strictKeys = DPE.record(keyUnion, DPE.boolean());
+ * const strictResult = strictKeys.parse({
+ * 	xPos: true,
+ * 	yPos: false,
+ * });
+ * 
+ * const withTemplate = DPE.record(
+ * 	DPE.templateLiteral(["id-", DPE.number()]),
+ * 	DPE.string(),
+ * );
+ * const templateResult = withTemplate.parse({ "id-1": "value" });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/record
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function record<GenericDataParserKey extends dataParsers.DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;
     value: GenericDataParserValue;

package/dist/dataParser/extended/record.mjs

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

package/dist/dataParser/extended/recover.cjs

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