@duplojs/utils 1.4.32 → 1.4.33

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

@@ -20,6 +20,33 @@ export interface DataParserRecoverExtended<GenericDefinition extends dataParsers
         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

@@ -19,25 +19,187 @@ export interface DataParserStringExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * 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
+     * 
+     */
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMin, "min">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
         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, [
         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, [
         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

@@ -20,6 +20,34 @@ export interface DataParserTemplateLiteralExtended<GenericDefinition extends dat
         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

@@ -20,13 +20,97 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    /**
+     * 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
+     * 
+     */
     min(min: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMin, "min">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
         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, [
         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

@@ -21,6 +21,34 @@ export interface DataParserTransformExtended<GenericDefinition extends dataParse
         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);

package/dist/dataParser/extended/tuple.cjs

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

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

@@ -26,6 +26,34 @@ export interface DataParserTupleExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserCheckerArrayMax
     ]>>;
 }
+/**
+ * Creates an extended data parser for tuples with a fixed shape.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.tuple(shape, definition?)` -> returns a tuple parser
+ * 
+ * Validates array inputs against the provided tuple shape, with an optional rest parser.
+ * 
+ * ```ts
+ * const parser = DPE.tuple([DPE.string(), DPE.number()]);
+ * const result = parser.parse(["id", 42]);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: [string, number]
+ * }
+ * 
+ * const withRest = DPE.tuple([DPE.string()], { rest: DPE.number() });
+ * const restResult = withRest.parse(["a", 1, 2]);
+ * 
+ * const bools = DPE.tuple([DPE.boolean(), DPE.boolean()]);
+ * const boolResult = bools.parse([true, false]);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/tuple
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function tuple<GenericShape extends dataParsers.TupleShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTupleExtended<MergeDefinition<dataParsers.DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;
 }>>;

package/dist/dataParser/extended/tuple.mjs

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

package/dist/dataParser/extended/union.cjs

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

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

@@ -20,6 +20,34 @@ export interface DataParserUnionExtended<GenericDefinition extends dataParsers.D
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
 }
+/**
+ * Creates an extended data parser that accepts one of multiple parsers.
+ * 
+ * **Supported call styles:**
+ * - Method: `DPE.union(options, definition?)` -> returns a union parser
+ * 
+ * Tries each option in order until one succeeds, then returns its output.
+ * 
+ * ```ts
+ * const parser = DPE.union([DPE.string(), DPE.number()]);
+ * const result = parser.parse("hello");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string | number
+ * }
+ * 
+ * const literals = DPE.union([DPE.literal("on"), DPE.literal("off")]);
+ * const literalResult = literals.parse("off");
+ * 
+ * const mixed = DPE.union([DPE.number(), DPE.boolean()]);
+ * const mixedResult = mixed.parse(true);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/union
+ * 
+ * @namespace DPE
+ * 
+ */
 export declare function union<GenericOptions extends dataParsers.UnionOptions, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;
 }>>;

package/dist/dataParser/extended/union.mjs

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

package/dist/dataParser/extended/unknown.cjs

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