@duplojs/utils 1.4.32 → 1.4.34

package/dist/clean/newType.d.ts

@@ -11,15 +11,78 @@ export interface NewType<GenericName extends string = string, GenericValue exten
 }
 export declare const newTypeHandlerKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type-handler", unknown>>;
 export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
+    /**
+     * The NewType name used as the brand (for example "userId").
+     * 
+     */
     readonly name: GenericName;
+    /**
+     * The DataParser used to validate and transform raw inputs.
+     * 
+     */
     readonly dataParser: DDataParser.Contract<GenericValue>;
+    /**
+     * The list of constraints applied to this NewType.
+     * 
+     */
     readonly constrains: GenericConstrainHandler;
+    /**
+     * Creates a NewType value and returns an Either.
+     * 
+     * ```ts
+     * const result = UserId.create(12);
+     * ```
+     * 
+     */
     create<const GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
     create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.EitherRight<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a NewType value and throws on error. Works with raw values or primitives.
+     * 
+     * ```ts
+     * const userId = UserId.createOrThrow(42);
+     * 
+     * const result = UserId.create(12);
+     * 
+     * const fromPrimitive = UserId.createOrThrow(
+     * 	C.Number.createOrThrow(5),
+     * );
+     * ```
+     * 
+     */
     createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>;
     createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>);
+    /**
+     * Creates a NewType value from an unknown input and returns an Either.
+     * 
+     * ```ts
+     * const unknownValue: unknown = 20;
+     * const maybe = UserId.createWithUnknown(unknownValue);
+     * 
+     * if (E.isRight(maybe)) {
+     * 	// maybe: E.EitherRight<"createNewType", UserId>
+     * }
+     * ```
+     * 
+     */
     createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a NewType value from an unknown input and throws on error.
+     * 
+     * ```ts
+     * const strictValue = UserId.createWithUnknownOrThrow(unknownValue);
+     * ```
+     * 
+     */
     createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>;
+    /**
+     * Checks if a value is a NewType of this handler (type guard).
+     * 
+     * ```ts
+     * UserId.is(result); // type guard
+     * ```
+     * 
+     */
     is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>>;
 }
 declare const CreateNewTypeError_base: new (params: {
@@ -31,6 +94,49 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
     dataParserError: DDataParser.DataParserError;
     constructor(newTypeName: string, data: unknown, dataParserError: DDataParser.DataParserError);
 }
+/**
+ * Creates a NewType handler for a domain-specific value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createNewType(name, dataParser, constraints?)` -> returns a handler
+ * 
+ * A NewType validates input with a DataParser, applies optional constraints, and brands the value to prevent accidental mix-ups across the domain.
+ * 
+ * ```ts
+ * const UserId = C.createNewType(
+ * 	"user-id",
+ * 	DP.number(),
+ * 	C.Positive,
+ * );
+ * 
+ * type UserId = C.GetNewType<typeof UserId>;
+ * 
+ * const userId = UserId.createOrThrow(42);
+ * 
+ * const result = UserId.create(12);
+ * 
+ * const fromPrimitive = UserId.createOrThrow(
+ * 	C.Number.createOrThrow(5),
+ * );
+ * 
+ * UserId.is(result); // type guard
+ * 
+ * const unknownValue: unknown = 20;
+ * const maybe = UserId.createWithUnknown(unknownValue);
+ * 
+ * if (E.isRight(maybe)) {
+ * 	// maybe: E.EitherRight<"createNewType", UserId>
+ * }
+ * 
+ * const strictValue = UserId.createWithUnknownOrThrow(unknownValue);
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/newType
+ * 
+ * @namespace C
+ * 
+ */
 export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>[]

package/dist/clean/newType.mjs

@@ -27,6 +27,9 @@ class CreateNewTypeError extends kindHeritage("create-new-type-error", createErr
         this.dataParserError = dataParserError;
     }
 }
+/**
+ * {@include clean/createNewType/index.md}
+ */
 function createNewType(name, dataParser, constraint) {
     const constrains = coalescing(constraint ?? []);
     const checkers = flatMap(constrains, ({ checkers }) => checkers);

package/dist/clean/primitive/base.cjs

@@ -58,11 +58,29 @@ function createPrimitive(dataParser) {
         is: is$2,
     });
 }
+/**
+ * {@include clean/String/index.md}
+ */
 const String = createPrimitive(index.string());
+/**
+ * {@include clean/Number/index.md}
+ */
 const Number = createPrimitive(index$1.number());
+/**
+ * {@include clean/BigInt/index.md}
+ */
 const BigInt = createPrimitive(index$2.bigint());
+/**
+ * {@include clean/Boolean/index.md}
+ */
 const Boolean = createPrimitive(boolean.boolean());
+/**
+ * {@include clean/Date/index.md}
+ */
 const Date = createPrimitive(date.date());
+/**
+ * {@include clean/Time/index.md}
+ */
 const Time = createPrimitive(index$3.time());
 
 exports.BigInt = BigInt;

package/dist/clean/primitive/base.d.ts

@@ -7,10 +7,62 @@ export interface Primitive<GenericValue extends EligiblePrimitive> extends Wrapp
 export declare const primitiveHandlerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/primitive-handler", unknown>>;
 export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = EligiblePrimitive> extends Kind<typeof primitiveHandlerKind.definition> {
     readonly dataParser: DDataParser.Contract<GenericValue>;
+    /**
+     * Creates a primitive value and returns an Either.
+     * 
+     * ```ts
+     * const result = C.String.create("hello");
+     * 
+     * if (E.isRight(result)) {
+     * 	// result: E.EitherRight<"createNewType", C.Primitive<"hello">>
+     * }
+     * ```
+     * 
+     */
     create<GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericData>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a primitive value and throws on error.
+     * 
+     * ```ts
+     * const value = C.Number.createOrThrow(42);
+     * // C.Primitive<42>
+     * ```
+     * 
+     */
     createOrThrow<GenericData extends GenericValue>(data: GenericData): Primitive<GenericData>;
+    /**
+     * Creates a primitive value from an unknown input and returns an Either.
+     * 
+     * ```ts
+     * const unknownValue: unknown = "world";
+     * const maybe = C.String.createWithUnknown(unknownValue);
+     * // E.EitherLeft<"createNewTypeError", DataParserError> | E.EitherRight<"createNewType", C.Primitive<string>>
+     * ```
+     * 
+     */
     createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericValue>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    /**
+     * Creates a primitive value from an unknown input and throws on error.
+     * 
+     * ```ts
+     * const strictValue = C.String.createWithUnknownOrThrow("ok");
+     * // C.Primitive<string>
+     * ```
+     * 
+     */
     createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): Primitive<GenericValue>;
+    /**
+     * Checks if a value is a primitive of this handler (type guard).
+     * 
+     * ```ts
+     * const input = true ? C.Number.createOrThrow(42) : C.String.createOrThrow("value");
+     * 
+     * if (C.Number.is(input)) {
+     * 	// input: C.Primitive<number>
+     * }
+     * ```
+     * 
+     */
     is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, Primitive<GenericValue>>;
 }
 declare const CreatePrimitiveError_base: new (params: {
@@ -21,16 +73,206 @@ export declare class CreatePrimitiveError extends CreatePrimitiveError_base {
     dataParserError: DDataParser.DataParserError;
     constructor(data: unknown, dataParserError: DDataParser.DataParserError);
 }
+/**
+ * Business primitive for string values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `String.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw strings in the domain and to share a common base type across NewTypes.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const result = C.String.create("hello");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createNewType", C.Primitive<"hello">>
+ * }
+ * 
+ * const value = C.String.createOrThrow("world");
+ * // value: C.Primitive<"world">
+ * 
+ * C.String.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const String: PrimitiveHandler<string>;
 export type String = ReturnType<typeof String["createWithUnknownOrThrow"]>;
+/**
+ * Business primitive for number values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `Number.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw numbers in the domain and to share a common base type across NewTypes.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const result = C.Number.create(42);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createNewType", C.Primitive<42>>
+ * }
+ * 
+ * const value = C.Number.createOrThrow(7);
+ * // value: C.Primitive<7>
+ * 
+ * C.Number.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Number: PrimitiveHandler<number>;
 export type Number = ReturnType<typeof Number["createWithUnknownOrThrow"]>;
+/**
+ * Business primitive for bigint values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `BigInt.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw bigint values in the domain and to share a common base type across NewTypes.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const result = C.BigInt.create(10n);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createNewType", C.Primitive<10n>>
+ * }
+ * 
+ * const value = C.BigInt.createOrThrow(99n);
+ * // value: C.Primitive<99n>
+ * 
+ * C.BigInt.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const BigInt: PrimitiveHandler<bigint>;
 export type BigInt = ReturnType<typeof BigInt["createWithUnknownOrThrow"]>;
+/**
+ * Business primitive for boolean values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `Boolean.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw booleans in the domain and to share a common base type across NewTypes.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const result = C.Boolean.create(true);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createNewType", C.Primitive<true>>
+ * }
+ * 
+ * const value = C.Boolean.createOrThrow(false);
+ * // value: C.Primitive<false>
+ * 
+ * C.Boolean.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Boolean: PrimitiveHandler<boolean>;
 export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
+/**
+ * Business primitive for date values (TheDate).
+ * 
+ * **Supported call styles:**
+ * - Classic: `Date.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw dates in the domain and to keep date operations typed and consistent.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const date = D.create("2024-01-01");
+ * 
+ * const result = C.Date.create(date);
+ * 
+ * if (E.isRight(result)) {
+ * // result: E.EitherRight<"createNewType", C.Primitive<D.TheDate>>
+ * }
+ * 
+ * const value = C.Date.createOrThrow(date);
+ * // value: C.Primitive<D.TheDate>
+ * 
+ * C.Date.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Date: PrimitiveHandler<`date${number}-` | `date${number}+`>;
 export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
+/**
+ * Business primitive for time values (TheTime).
+ * 
+ * **Supported call styles:**
+ * - Classic: `Time.create(value)` -> returns Either
+ * 
+ * Use it to avoid raw durations in the domain and to keep time operations typed and consistent.
+ * 
+ * Business primitives are an alternative to raw TypeScript strings and numbers.
+ * Instead of manipulating bare values, each primitive is wrapped in a container.
+ * Result: safer, more explicit data, better aligned with the domain.
+ * 
+ * ```ts
+ * const theTime = D.createTheTime(3_600_000);
+ * 
+ * const result = C.Time.create(theTime);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.EitherRight<"createNewType", C.Primitive<D.TheTime>>
+ * }
+ * 
+ * const value = C.Time.createOrThrow(theTime);
+ * // value: C.Primitive<D.TheTime>
+ * 
+ * C.Time.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
+ * 
+ * @namespace C
+ * 
+ */
 export declare const Time: PrimitiveHandler<`time${number}-` | `time${number}+`>;
 export type Time = ReturnType<typeof Time["createWithUnknownOrThrow"]>;
 export type Primitives = (String | Number | BigInt | Boolean | Date | Time);

package/dist/clean/primitive/base.mjs

@@ -56,11 +56,29 @@ function createPrimitive(dataParser) {
         is,
     });
 }
+/**
+ * {@include clean/String/index.md}
+ */
 const String = createPrimitive(string());
+/**
+ * {@include clean/Number/index.md}
+ */
 const Number = createPrimitive(number());
+/**
+ * {@include clean/BigInt/index.md}
+ */
 const BigInt = createPrimitive(bigint());
+/**
+ * {@include clean/Boolean/index.md}
+ */
 const Boolean = createPrimitive(boolean());
+/**
+ * {@include clean/Date/index.md}
+ */
 const Date = createPrimitive(date());
+/**
+ * {@include clean/Time/index.md}
+ */
 const Time = createPrimitive(time());
 
 export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind };

package/dist/clean/primitive/operations/date/dateAddTime.d.ts

@@ -1,4 +1,39 @@
 import { type Date, type Time } from "../../base";
 import { type TheTime } from "../../../../date";
+/**
+ * Adds a time duration to a Date and returns a new wrapped Date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateAddTime(date, time)` -> returns a Date
+ * - Curried: `dateAddTime(time)` -> returns a function waiting for the date
+ * 
+ * Use it to move dates forward while keeping values wrapped.
+ * 
+ * ```ts
+ * const date = C.Date.createOrThrow(D.create("2024-01-01"));
+ * const oneHour = C.Time.createOrThrow(D.createTheTime(3_600_000));
+ * 
+ * const later = C.dateAddTime(date, oneHour);
+ * // later: C.Date
+ * 
+ * const curried = pipe(
+ * 	date,
+ * 	C.dateAddTime(D.createTheTime(60_000)),
+ * );
+ * // curried: C.Date
+ * 
+ * const mixed = C.dateAddTime(
+ * 	C.Date.createOrThrow(D.create("2024-01-02")),
+ * 	D.createTheTime(500),
+ * );
+ * // mixed: C.Date
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateAddTime
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateAddTime(time: Time | TheTime): (primitive: Date) => Date;
 export declare function dateAddTime(primitive: Date, time: Time | TheTime): Date;

package/dist/clean/primitive/operations/date/dateGreaterThan.d.ts

@@ -1,4 +1,28 @@
 import { type Date } from "../../base";
 import { type TheDate } from "../../../../date";
+/**
+ * Checks whether a Date is after a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateGreaterThan(date, threshold)` -> returns a boolean
+ * - Curried: `dateGreaterThan(threshold)` -> returns a function waiting for the date
+ * 
+ * Use it to compare wrapped dates or raw TheDate values.
+ * 
+ * ```ts
+ * const date = C.Date.createOrThrow(D.create("2024-03-01"));
+ * const threshold = D.create("2024-02-29");
+ * 
+ * if (C.dateGreaterThan(date, threshold)) {
+ * 	// date is after threshold
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateGreaterThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateGreaterThan(threshold: Date | TheDate): (primitive: Date) => boolean;
 export declare function dateGreaterThan(primitive: Date, threshold: Date | TheDate): boolean;

package/dist/clean/primitive/operations/date/dateLessThan.d.ts

@@ -1,4 +1,28 @@
 import { type Date } from "../../base";
 import { type TheDate } from "../../../../date";
+/**
+ * Checks whether a Date is before a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateLessThan(date, threshold)` -> returns a boolean
+ * - Curried: `dateLessThan(threshold)` -> returns a function waiting for the date
+ * 
+ * Use it to compare wrapped dates or raw TheDate values.
+ * 
+ * ```ts
+ * const date = C.Date.createOrThrow(D.create("2024-02-29"));
+ * const threshold = D.create("2024-03-01");
+ * 
+ * if (C.dateLessThan(date, threshold)) {
+ * 	// date is before threshold
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateLessThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateLessThan(threshold: Date | TheDate): (primitive: Date) => boolean;
 export declare function dateLessThan(primitive: Date, threshold: Date | TheDate): boolean;

package/dist/clean/primitive/operations/date/dateMax.cjs

@@ -4,6 +4,9 @@ var max = require('../../../../date/max.cjs');
 var wrapValue = require('../../../../common/wrapValue.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/dateMax/index.md}
+ */
 function dateMax(input) {
     return wrapValue.wrapValue(max.max(input.map(unwrap.unwrap)));
 }

package/dist/clean/primitive/operations/date/dateMax.d.ts

@@ -1,4 +1,40 @@
 import { type TheDate } from "../../../../date";
 import { type Date } from "../../base";
 import { type AnyTuple } from "../../../../common";
+/**
+ * Returns the latest date from a tuple of Date values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateMax(input)` -> returns a Date
+ * 
+ * The input can mix wrapped Dates and raw TheDate values.
+ * 
+ * ```ts
+ * const latest = C.dateMax([
+ * 	C.Date.createOrThrow(D.create("2024-03-01")),
+ * 	D.create("2024-02-01"),
+ * 	D.create("2024-04-01"),
+ * ]);
+ * // latest: C.Date
+ * 
+ * const fromRaw = C.dateMax([
+ * 	D.create("2024-01-05"),
+ * 	D.create("2024-01-03"),
+ * 	D.create("2024-01-10"),
+ * ]);
+ * // fromRaw: C.Date
+ * 
+ * const mixed = C.dateMax([
+ * 	C.Date.createOrThrow(D.create("2024-01-08")),
+ * 	D.create("2024-01-07"),
+ * ]);
+ * // mixed: C.Date
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateMax
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateMax(input: AnyTuple<Date | TheDate>): Date;

package/dist/clean/primitive/operations/date/dateMax.mjs

@@ -2,6 +2,9 @@ import { max } from '../../../../date/max.mjs';
 import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/dateMax/index.md}
+ */
 function dateMax(input) {
     return wrapValue(max(input.map(unwrap)));
 }

package/dist/clean/primitive/operations/date/dateMin.cjs

@@ -4,6 +4,9 @@ var min = require('../../../../date/min.cjs');
 var wrapValue = require('../../../../common/wrapValue.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/dateMin/index.md}
+ */
 function dateMin(input) {
     return wrapValue.wrapValue(min.min(input.map(unwrap.unwrap)));
 }

package/dist/clean/primitive/operations/date/dateMin.d.ts

@@ -1,4 +1,40 @@
 import { type TheDate } from "../../../../date";
 import { type Date } from "../../base";
 import { type AnyTuple } from "../../../../common";
+/**
+ * Returns the earliest date from a tuple of Date values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateMin(input)` -> returns a Date
+ * 
+ * The input can mix wrapped Dates and raw TheDate values.
+ * 
+ * ```ts
+ * const earliest = C.dateMin([
+ * 	C.Date.createOrThrow(D.create("2024-03-01")),
+ * 	D.create("2024-02-01"),
+ * 	D.create("2024-04-01"),
+ * ]);
+ * // earliest: C.Date
+ * 
+ * const fromRaw = C.dateMin([
+ * 	D.create("2024-01-05"),
+ * 	D.create("2024-01-03"),
+ * 	D.create("2024-01-10"),
+ * ]);
+ * // fromRaw: C.Date
+ * 
+ * const mixed = C.dateMin([
+ * 	C.Date.createOrThrow(D.create("2024-01-08")),
+ * 	D.create("2024-01-07"),
+ * ]);
+ * // mixed: C.Date
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateMin
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateMin(input: AnyTuple<Date | TheDate>): Date;