@duplojs/utils 1.4.32 → 1.4.34

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

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

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

@@ -12,14 +12,35 @@ export interface DataParserRecoverExtended<GenericDefinition extends dataParsers
         dataParsers.DataParserRecoverCheckers<Output<this>>,
         ...dataParsers.DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserRecoverExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
 }
+/**
+ * Creates an extended data parser that recovers with a fallback value on error.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.recover(inner, recoveredValue, definition?)` -> returns a recover parser
+ * 
+ * Runs the inner parser and returns the recovered value when parsing fails.
+ * 
+ * ```ts
+ * const parser = DPE.recover(DPE.number(), 0);
+ * const result = parser.parse("not-a-number");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const withString = DPE.recover(DPE.string(), "fallback");
+ * const stringResult = withString.parse(123);
+ * 
+ * const okResult = parser.parse(10);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/recover
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;

package/dist/dataParser/extended/recover.mjs

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

package/dist/dataParser/extended/string.cjs

@@ -9,6 +9,9 @@ var max = require('../parsers/string/checkers/max.cjs');
 var min = require('../parsers/string/checkers/min.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/string/index.md}
+ */
 function string(definition) {
     const self = baseExtended.dataParserExtendedInit(index.string(definition), {
         min(self, min$1, definition) {
@@ -24,11 +27,17 @@ function string(definition) {
     return string.overrideHandler.apply(self);
 }
 string.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/string");
+/**
+ * {@include dataParser/extended/email/index.md}
+ */
 function email(definition) {
     return string({
         checkers: [email$1.checkerEmail(definition)],
     });
 }
+/**
+ * {@include dataParser/extended/url/index.md}
+ */
 function url(definition) {
     return string({
         checkers: [url$1.checkerUrl(definition)],

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

@@ -12,32 +12,182 @@ export interface DataParserStringExtended<GenericDefinition extends dataParsers.
         dataParsers.DataParserStringCheckers,
         ...dataParsers.DataParserStringCheckers[]
     ], GenericChecker>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
     /**
-     * @deprecated Method with unreliable typing.
+     * Adds a minimum length checker to a string parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns a string parser
+     * 
+     * Ensures the string length is at least the given minimum.
+     * 
+     * ```ts
+     * const parser = DPE.string().min(3);
+     * const result = parser.parse("abc");
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: string
+     * }
+     * 
+     * const withMessage = DPE.string().min(5, { errorMessage: "string.too-short" });
+     * const messageResult = withMessage.parse("hello");
+     * 
+     * const chained = DPE.string().min(2).max(5);
+     * const chainedResult = chained.parse("abcd");
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+     * 
+     * @namespace DPE
+     * 
      */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionString>(definition: GenericDefinition): DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
-    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMin, "min">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.DataParserCheckerStringMin
-    ]>>;
-    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMax, "max">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.DataParserCheckerStringMax
-    ]>>;
-    regex(regex: RegExp, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringRegex, "regex">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.DataParserCheckerStringRegex
-    ]>>;
+    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMin, "min">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerStringMin]>>;
+    /**
+     * Adds a maximum length checker to a string parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns a string parser
+     * 
+     * Ensures the string length is at most the given maximum.
+     * 
+     * ```ts
+     * const parser = DPE.string().max(5);
+     * const result = parser.parse("short");
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: string
+     * }
+     * 
+     * const withMessage = DPE.string().max(10, { errorMessage: "string.too-long" });
+     * const messageResult = withMessage.parse("hello");
+     * 
+     * const chained = DPE.string().min(2).max(4);
+     * const chainedResult = chained.parse("abcd");
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+     * 
+     * @namespace DPE
+     * 
+     */
+    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMax, "max">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerStringMax]>>;
+    /**
+     * Adds a regex checker to a string parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.regex(regex, definition?)` -> returns a string parser
+     * 
+     * Ensures the string matches the provided regular expression.
+     * 
+     * ```ts
+     * const parser = DPE.string().regex(/^[A-Z][a-z]+$/);
+     * const result = parser.parse("Duplo");
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: string
+     * }
+     * 
+     * const withMessage = DPE.string().regex(/^[a-z-]+$/, { errorMessage: "string.bad-format" });
+     * const messageResult = withMessage.parse("slug-value");
+     * 
+     * const chained = DPE.string().min(2).regex(/^ab/);
+     * const chainedResult = chained.parse("ab");
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+     * 
+     * @namespace DPE
+     * 
+     */
+    regex(regex: RegExp, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringRegex, "regex">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerStringRegex]>>;
 }
+/**
+ * Creates an extended data parser for strings.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.string(definition?)` -> returns a string parser
+ * 
+ * Validates that the input is a string and exposes string-specific methods like min, max, and regex.
+ * 
+ * ```ts
+ * const parser = DPE.string().min(3).max(10);
+ * const result = parser.parse("DuploJS");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const withRegex = DPE.string().regex(/^[A-Z][a-z]+$/);
+ * const regexResult = withRegex.parse("Duplo");
+ * 
+ * const coerceParser = DPE.coerce.string().min(2);
+ * const coerceResult = coerceParser.parse(123);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function string<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace string {
     var overrideHandler: import("../../common").OverrideHandler<DataParserStringExtended<dataParsers.DataParserDefinitionString>>;
 }
+/**
+ * Creates an extended data parser for email strings.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.email(definition?)` -> returns an email parser
+ * 
+ * Validates that the input is a string formatted as an email address.
+ * 
+ * ```ts
+ * const parser = DPE.email();
+ * const result = parser.parse("a@b.com");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const withMessage = DPE.email({ errorMessage: "email.format-invalid" });
+ * const messageResult = withMessage.parse("a@b.com");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function email(definition?: Partial<dataParsers.DataParserCheckerDefinitionEmail>): DataParserStringExtended<{
     readonly checkers: readonly [dataParsers.DataParserCheckerEmail];
     readonly errorMessage?: string | undefined;
     readonly coerce: boolean;
 }>;
+/**
+ * Creates an extended data parser for URL strings.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.url(definition?)` -> returns a URL parser
+ * 
+ * Validates that the input is a string formatted as a URL.
+ * 
+ * ```ts
+ * const parser = DPE.url();
+ * const result = parser.parse("https://example.com");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const withMessage = DPE.url({ errorMessage: "url.format-invalid" });
+ * const messageResult = withMessage.parse("https://example.com");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function url(definition?: Partial<dataParsers.DataParserCheckerDefinitionUrl>): DataParserStringExtended<{
     readonly checkers: readonly [dataParsers.DataParserCheckerUrl];
     readonly errorMessage?: string | undefined;

package/dist/dataParser/extended/string.mjs

@@ -7,6 +7,9 @@ import { checkerStringMax } from '../parsers/string/checkers/max.mjs';
 import { checkerStringMin } from '../parsers/string/checkers/min.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/string/index.md}
+ */
 function string(definition) {
     const self = dataParserExtendedInit(string$1(definition), {
         min(self, min, definition) {
@@ -22,11 +25,17 @@ function string(definition) {
     return string.overrideHandler.apply(self);
 }
 string.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/string");
+/**
+ * {@include dataParser/extended/email/index.md}
+ */
 function email(definition) {
     return string({
         checkers: [checkerEmail(definition)],
     });
 }
+/**
+ * {@include dataParser/extended/url/index.md}
+ */
 function url(definition) {
     return string({
         checkers: [checkerUrl(definition)],

package/dist/dataParser/extended/templateLiteral.cjs

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

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

@@ -12,14 +12,36 @@ export interface DataParserTemplateLiteralExtended<GenericDefinition extends dat
         dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,
         ...dataParsers.DataParserTemplateLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral>(definition: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTemplateLiteralExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
 }
+/**
+ * Creates an extended data parser for deterministic template literal strings.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.templateLiteral(template, definition?)` -> returns a template literal parser
+ * 
+ * Validates that the input matches the provided template literal shape.
+ * 
+ * ```ts
+ * const parser = DPE.templateLiteral(["user-", DPE.number()]);
+ * const result = parser.parse("user-42");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const orderParser = DPE.templateLiteral(["order-", DPE.literal("vip"), "-", DPE.number()]);
+ * const orderResult = orderParser.parse("order-vip-12");
+ * 
+ * const withLiteral = DPE.templateLiteral([DPE.literal("id-"), DPE.number()]);
+ * const literalResult = withLiteral.parse("id-1");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/templateLiteral
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function templateLiteral<const GenericTemplate extends dataParsers.TemplateLiteralShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
     template: GenericTemplate;
 }>>;

package/dist/dataParser/extended/templateLiteral.mjs

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

package/dist/dataParser/extended/time.cjs

@@ -6,6 +6,9 @@ var max = require('../parsers/time/checkers/max.cjs');
 var min = require('../parsers/time/checkers/min.cjs');
 var override = require('../../common/override.cjs');
 
+/**
+ * {@include dataParser/extended/time/index.md}
+ */
 function time(definition) {
     const self = baseExtended.dataParserExtendedInit(index.time(definition), {
         min(self, min$1, definition) {

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

@@ -13,20 +13,94 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
         dataParsers.DataParserTimeCheckers,
         ...dataParsers.DataParserTimeCheckers[]
     ], GenericChecker>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
     /**
-     * @deprecated Method with unreliable typing.
+     * Adds a minimum time checker to a time parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns a time parser
+     * 
+     * Ensures the time is greater than the provided minimum.
+     * 
+     * ```ts
+     * const parser = DPE.time().min("time0+");
+     * const result = parser.parse("time10+");
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: TheTime
+     * }
+     * 
+     * const withMessage = DPE.time().min("time0+", { errorMessage: "time.too-small" });
+     * const messageResult = withMessage.parse("time0+");
+     * 
+     * const chained = DPE.time().min("time0+").max("time100+");
+     * const chainedResult = chained.parse("time10+");
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+     * 
+     * @namespace DPE
+     * 
      */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTime>(definition: GenericDefinition): DataParserTimeExtended<MergeDefinition<dataParsers.DataParserDefinitionTime, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
-    min(min: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMin, "min">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.DataParserCheckerTimeMin
-    ]>>;
-    max(max: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMax, "max">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.DataParserCheckerTimeMax
-    ]>>;
+    min(min: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMin, "min">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerTimeMin]>>;
+    /**
+     * Adds a maximum time checker to a time parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns a time parser
+     * 
+     * Ensures the time is smaller than the provided maximum.
+     * 
+     * ```ts
+     * const parser = DPE.time().max("time100+");
+     * const result = parser.parse("time10+");
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: TheTime
+     * }
+     * 
+     * const withMessage = DPE.time().max("time100+", { errorMessage: "time.too-large" });
+     * const messageResult = withMessage.parse("time100+");
+     * 
+     * const chained = DPE.time().min("time0+").max("time100+");
+     * const chainedResult = chained.parse("time10+");
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+     * 
+     * @namespace DPE
+     * 
+     */
+    max(max: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMax, "max">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerTimeMax]>>;
 }
+/**
+ * Creates an extended data parser for TheTime values.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.time(definition?)` -> returns a time parser
+ * 
+ * Validates TheTime values and exposes time-specific methods like min and max.
+ * 
+ * ```ts
+ * const parser = DPE.time().min("time0+").max("time100+");
+ * const result = parser.parse("time10+");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: TheTime
+ * }
+ * 
+ * const coerceParser = DPE.coerce.time();
+ * const coerceResult = coerceParser.parse("10:20:00");
+ * 
+ * const minOnly = DPE.time().min("time0+");
+ * const minResult = minOnly.parse("time0+");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function time<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionTime> = never>(definition?: GenericDefinition): DataParserTimeExtended<MergeDefinition<dataParsers.DataParserDefinitionTime, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace time {
     var overrideHandler: import("../../common").OverrideHandler<DataParserTimeExtended<dataParsers.DataParserDefinitionTime>>;

package/dist/dataParser/extended/time.mjs

@@ -4,6 +4,9 @@ import { checkerTimeMax } from '../parsers/time/checkers/max.mjs';
 import { checkerTimeMin } from '../parsers/time/checkers/min.mjs';
 import { createOverride } from '../../common/override.mjs';
 
+/**
+ * {@include dataParser/extended/time/index.md}
+ */
 function time(definition) {
     const self = dataParserExtendedInit(time$1(definition), {
         min(self, min, definition) {

package/dist/dataParser/extended/transform.cjs

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

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

@@ -13,14 +13,36 @@ export interface DataParserTransformExtended<GenericDefinition extends dataParse
         dataParsers.DataParserTransformCheckers<Output<this>>,
         ...dataParsers.DataParserTransformCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTransform>(definition: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, GenericDefinition>>;
-    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, [
-        dataParsers.CheckerRefineImplementation<Output<this>>
-    ]>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTransformExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
 }
+/**
+ * Creates an extended transform parser from another parser.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.transform(inner, theFunction, definition?)` -> returns a transform parser
+ * 
+ * Runs the inner parser and applies a transformation function to its output.
+ * 
+ * ```ts
+ * const parser = DPE.transform(DPE.string(), (value) => value.length);
+ * const result = parser.parse("Duplo");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const toUpper = DPE.transform(DPE.string(), (value) => value.toUpperCase());
+ * const upperResult = toUpper.parse("duplo");
+ * 
+ * const double = DPE.transform(DPE.number(), (value) => value * 2);
+ * const doubleResult = double.parse(3);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/transform
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     theFunction(input: Output<GenericDataParser>): GenericOutput;

package/dist/dataParser/extended/transform.mjs

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