@duplojs/utils 1.4.57 → 1.4.58

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

@@ -7,7 +7,7 @@ export declare const constrainedTypeKind: import("../..").KindHandler<import("..
 export interface ConstrainedType<GenericName extends string, GenericValue extends unknown> extends Kind<typeof constrainedTypeKind.definition, Record<GenericName, unknown>>, WrappedValue<GenericValue> {
 }
 export declare const constraintHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraint-handler", unknown>>;
-export interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DDataParser.DataParserChecker[] = readonly DDataParser.DataParserChecker[]> extends Kind<typeof constraintHandlerKind.definition> {
+export interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DDataParser.DataParserChecker[] = readonly DDataParser.DataParserChecker[], GenericPrimitiveInput extends unknown = unknown> extends Kind<typeof constraintHandlerKind.definition> {
     /**
      * The constraint name used as the internal marker (for example "email").
      * 
@@ -36,6 +36,7 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
      * 
      */
     create<GenericData extends GenericPrimitiveValue>(data: GenericData): (DEither.Right<"createConstrainedType", ConstrainedType<GenericName, GenericData>> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
+    create(data: GenericPrimitiveInput): (DEither.Right<"createConstrainedType", ConstrainedType<GenericName, GenericPrimitiveValue>> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
     create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.Right<"createConstrainedType", (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>)> | DEither.Left<"createConstrainedTypeError", DDataParser.DataParserError>);
     /**
      * Creates a constrained value and throws on error.
@@ -47,6 +48,7 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
      * 
      */
     createOrThrow<GenericData extends GenericPrimitiveValue>(data: GenericData): ConstrainedType<GenericName, GenericData>;
+    createOrThrow(data: GenericPrimitiveInput): ConstrainedType<GenericName, GenericPrimitiveValue>;
     createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & ConstrainedType<GenericName, Unwrap<GenericPrimitive>>);
     /**
      * Creates a constrained value from an unknown input and returns an Either.
@@ -134,12 +136,12 @@ export declare class CreateConstrainedTypeError extends CreateConstrainedTypeErr
  * @namespace C
  * 
  */
-export declare function createConstraint<GenericName extends string, GenericPrimitiveValue extends EligiblePrimitive, const GenericChecker extends (DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue> | readonly [
+export declare function createConstraint<GenericName extends string, GenericPrimitiveValue extends EligiblePrimitive, GenericPrimitiveInput extends unknown, const GenericChecker extends (DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue> | readonly [
     DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
     ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]
-]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>>;
+]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue, GenericPrimitiveInput>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>, GenericPrimitiveInput>;
 export declare namespace createConstraint {
-    var overrideHandler: import("../..").OverrideHandler<ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[]>>;
+    var overrideHandler: import("../..").OverrideHandler<ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[], unknown>>;
 }
 export type GetConstraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
 export {};

package/dist/clean/constraint/defaultConstraint/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./number";
 export * from "./string";
+export * from "./time";

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -28,7 +28,7 @@ import { type OnlyLiteralNumber } from "../../../common";
  * @namespace C
  * 
  */
-export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt]>;
+export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt], never>;
 export type Int = GetConstraint<typeof Int>;
 /**
  * Constraint handler that validates strictly positive numbers (>= 1).
@@ -57,7 +57,7 @@ export type Int = GetConstraint<typeof Int>;
  * @namespace C
  * 
  */
-export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin]>;
+export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin], never>;
 export type Positive = GetConstraint<typeof Positive>;
 /**
  * Constraint handler that validates strictly negative numbers (<= -1).
@@ -86,7 +86,7 @@ export type Positive = GetConstraint<typeof Positive>;
  * @namespace C
  * 
  */
-export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
+export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax], never>;
 export type Negative = GetConstraint<typeof Negative>;
 /**
  * Constraint factory that validates numbers greater than or equal to a minimum.
@@ -116,7 +116,7 @@ export type Negative = GetConstraint<typeof Negative>;
  * @namespace C
  * 
  */
-export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMin]>;
+export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMin], never>;
 export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin<GenericValue>>;
 /**
  * Constraint factory that validates numbers less than or equal to a maximum.
@@ -146,7 +146,7 @@ export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin
  * @namespace C
  * 
  */
-export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax]>;
+export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax], never>;
 export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax<GenericValue>>;
 /**
  * Constraint handler that validates strictly positive integers (>= 1).
@@ -175,5 +175,5 @@ export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax
  * @namespace C
  * 
  */
-export declare const PositiveInt: import("..").ConstraintHandler<"positive-int", number, readonly [DDataParser.DataParserCheckerInt, DDataParser.DataParserCheckerNumberMin]>;
+export declare const PositiveInt: import("..").ConstraintHandler<"positive-int", number, readonly [DDataParser.DataParserCheckerInt, DDataParser.DataParserCheckerNumberMin], never>;
 export type PositiveInt = GetConstraint<typeof PositiveInt>;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -28,7 +28,7 @@ import { type OnlyLiteralNumber } from "../../../common";
  * @namespace C
  * 
  */
-export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail]>;
+export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail], never>;
 export type Email = GetConstraint<typeof Email>;
 /**
  * Constraint handler that validates a URL string.
@@ -57,7 +57,7 @@ export type Email = GetConstraint<typeof Email>;
  * @namespace C
  * 
  */
-export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
+export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl], never>;
 export type Url = GetConstraint<typeof Url>;
 /**
  * Constraint factory that validates strings with a minimum length.
@@ -87,7 +87,7 @@ export type Url = GetConstraint<typeof Url>;
  * @namespace C
  * 
  */
-export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMin]>;
+export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMin], never>;
 export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMin<GenericValue>>>;
 /**
  * Constraint factory that validates strings with a maximum length.
@@ -117,5 +117,5 @@ export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<ty
  * @namespace C
  * 
  */
-export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMax]>;
+export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMax], never>;
 export type StringMax<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMax<GenericValue>>>;

package/dist/clean/constraint/defaultConstraint/time.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var base = require('../base.cjs');
+var base$1 = require('../../primitive/base.cjs');
+var min = require('../../../dataParser/parsers/time/checkers/min.cjs');
+var theTime = require('../../../date/theTime.cjs');
+var max = require('../../../dataParser/parsers/time/checkers/max.cjs');
+
+/**
+ * {@include clean/PositiveTime/index.md}
+ */
+const PositiveTime = base.createConstraint("positive-time", base$1.Time, min.checkerTimeMin(theTime.TheTime.new(1)));
+/**
+ * {@include clean/NegativeTime/index.md}
+ */
+const NegativeTime = base.createConstraint("negative-time", base$1.Time, max.checkerTimeMax(theTime.TheTime.new(-1)));
+
+exports.NegativeTime = NegativeTime;
+exports.PositiveTime = PositiveTime;

package/dist/clean/constraint/defaultConstraint/time.d.ts

@@ -0,0 +1,61 @@
+import { type GetConstraint } from "../base";
+import * as DDataParser from "../../../dataParser";
+import { TheTime } from "../../../date";
+/**
+ * Constraint handler that validates strictly positive durations (>= 1 millisecond).
+ * 
+ * **Supported call styles:**
+ * - Classic: `PositiveTime.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate time values and to constrain NewTypes to positive durations.
+ * 
+ * ```ts
+ * const result = C.PositiveTime.create(D.createTime(1, "second"));
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"positive-time", D.TheTime>>
+ * }
+ * 
+ * const value = C.PositiveTime.createOrThrow(D.createTime(500, "millisecond"));
+ * // value: C.ConstrainedType<"positive-time", D.TheTime>
+ * 
+ * C.PositiveTime.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare const PositiveTime: import("..").ConstraintHandler<"positive-time", TheTime, readonly [DDataParser.DataParserCheckerTimeMin], number | TheTime | `time${number}-` | `time${number}+`>;
+export type PositiveTime = GetConstraint<typeof PositiveTime>;
+/**
+ * Constraint handler that validates strictly negative durations (<= -1 millisecond).
+ * 
+ * **Supported call styles:**
+ * - Classic: `NegativeTime.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate time values and to constrain NewTypes to negative durations.
+ * 
+ * ```ts
+ * const result = C.NegativeTime.create(D.createTime(-1, "second"));
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"negative-time", D.TheTime>>
+ * }
+ * 
+ * const value = C.NegativeTime.createOrThrow(D.createTime(-500, "millisecond"));
+ * // value: C.ConstrainedType<"negative-time", D.TheTime>
+ * 
+ * C.NegativeTime.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare const NegativeTime: import("..").ConstraintHandler<"negative-time", TheTime, readonly [DDataParser.DataParserCheckerTimeMax], number | TheTime | `time${number}-` | `time${number}+`>;
+export type NegativeTime = GetConstraint<typeof NegativeTime>;

package/dist/clean/constraint/defaultConstraint/time.mjs

@@ -0,0 +1,16 @@
+import { createConstraint } from '../base.mjs';
+import { Time } from '../../primitive/base.mjs';
+import { checkerTimeMin } from '../../../dataParser/parsers/time/checkers/min.mjs';
+import { TheTime } from '../../../date/theTime.mjs';
+import { checkerTimeMax } from '../../../dataParser/parsers/time/checkers/max.mjs';
+
+/**
+ * {@include clean/PositiveTime/index.md}
+ */
+const PositiveTime = createConstraint("positive-time", Time, checkerTimeMin(TheTime.new(1)));
+/**
+ * {@include clean/NegativeTime/index.md}
+ */
+const NegativeTime = createConstraint("negative-time", Time, checkerTimeMax(TheTime.new(-1)));
+
+export { NegativeTime, PositiveTime };

package/dist/clean/constraint/set.d.ts

@@ -5,7 +5,7 @@ import * as DEither from "../../either";
 import * as DArray from "../../array";
 import type * as DDataParser from "../../dataParser";
 export declare const constraintsSetHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraints-set-handler", unknown>>;
-export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof constraintsSetHandlerKind.definition> {
+export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly [], GenericPrimitiveInput extends unknown = unknown> extends Kind<typeof constraintsSetHandlerKind.definition> {
     /**
      * The primitive handler used to validate and wrap values (e.g. `C.String`, `C.Number`).
      * 
@@ -29,6 +29,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * 
      */
     create<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericInput> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    create(data: GenericPrimitiveInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
     create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.Right<"createConstraintsSet", (GenericPrimitive & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
     /**
      * Creates a constrained value and throws on error. Works with raw values or primitives.
@@ -43,6 +44,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * 
      */
     createOrThrow<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (Primitive<GenericInput> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    createOrThrow(data: GenericPrimitiveInput): (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
     createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
     /**
      * Creates a constrained value from an unknown input and returns an Either.
@@ -136,12 +138,12 @@ export declare class CreateConstraintsSetError extends CreateConstraintsSetError
  * @namespace C
  * 
  */
-export declare function createConstraintsSet<GenericPrimitiveValue extends EligiblePrimitive, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]> | readonly [
+export declare function createConstraintsSet<GenericPrimitiveValue extends EligiblePrimitive, GenericPrimitiveInput extends unknown, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>[]
-]) = never>(primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, constraint: GenericConstrainHandler): ConstraintsSetHandler<GenericPrimitiveValue, DArray.ArrayCoalescing<GenericConstrainHandler>>;
+]) = never>(primitiveHandler: PrimitiveHandler<GenericPrimitiveValue, GenericPrimitiveInput>, constraint: GenericConstrainHandler): ConstraintsSetHandler<GenericPrimitiveValue, DArray.ArrayCoalescing<GenericConstrainHandler>, GenericPrimitiveInput>;
 export declare namespace createConstraintsSet {
-    var overrideHandler: import("../..").OverrideHandler<ConstraintsSetHandler<EligiblePrimitive, readonly []>>;
+    var overrideHandler: import("../..").OverrideHandler<ConstraintsSetHandler<EligiblePrimitive, readonly [], unknown>>;
 }
 export type GetConstraints<GenericHandler extends ConstraintsSetHandler<EligiblePrimitive, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["constraints"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
 export {};

package/dist/clean/entity.d.ts

@@ -32,8 +32,9 @@ export type EntityRawProperties<GenericPropertiesDefinition extends EntityProper
         ...InferredValue[]
     ] : readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : unknown);
 }>;
+type GetInputFromNewTypeHandler<GenericNewTypeHandler extends NewTypeHandler> = GenericNewTypeHandler extends NewTypeHandler<any, infer InferredValue, any, infer InferredInput> ? IsEqual<InferredInput, never> extends true ? InferredValue : InferredInput : never;
 export type PropertiesToMapOfEntity<GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> = SimplifyTopLevel<{
-    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]>> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop][number]>> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? Unwrap<GetNewType<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never>> extends infer InferredValue ? (Or<[
+    readonly [Prop in keyof GenericPropertiesDefinition]: (GenericPropertiesDefinition[Prop] extends EntitySimplePropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop]> : GenericPropertiesDefinition[Prop] extends EntityUnionPropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop][number]> : GenericPropertiesDefinition[Prop] extends EntityAdvancedPropertyDefinition ? GetInputFromNewTypeHandler<GenericPropertiesDefinition[Prop]["type"] extends EntityUnionPropertyDefinition ? GenericPropertiesDefinition[Prop]["type"][number] : GenericPropertiesDefinition[Prop]["type"] extends EntitySimplePropertyDefinition ? GenericPropertiesDefinition[Prop]["type"] : never> extends infer InferredValue ? (Or<[
         IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true>,
         IsExtends<GenericPropertiesDefinition[Prop]["inArray"], object>
     ]> extends true ? readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : never);

package/dist/clean/index.cjs

@@ -11,6 +11,7 @@ var maybe = require('./maybe.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
+var time = require('./constraint/defaultConstraint/time.cjs');
 var set = require('./constraint/set.cjs');
 var base$1 = require('./primitive/base.cjs');
 var equal = require('./primitive/operations/equal.cjs');
@@ -75,6 +76,8 @@ exports.Email = string.Email;
 exports.StringMax = string.StringMax;
 exports.StringMin = string.StringMin;
 exports.Url = string.Url;
+exports.NegativeTime = time.NegativeTime;
+exports.PositiveTime = time.PositiveTime;
 exports.CreateConstraintsSetError = set.CreateConstraintsSetError;
 exports.constraintsSetHandlerKind = set.constraintsSetHandlerKind;
 exports.createConstraintsSet = set.createConstraintsSet;

package/dist/clean/index.mjs

@@ -9,6 +9,7 @@ export { none, some } from './maybe.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
 export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt } from './constraint/defaultConstraint/number.mjs';
 export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';
+export { NegativeTime, PositiveTime } from './constraint/defaultConstraint/time.mjs';
 export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet } from './constraint/set.mjs';
 export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, createPrimitive, primitiveHandlerKind } from './primitive/base.mjs';
 export { equal } from './primitive/operations/equal.mjs';

package/dist/clean/newType.d.ts

@@ -1,4 +1,4 @@
-import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing, type DeepReadonly } from "..";
+import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing, type DeepReadonly, type IsEqual } from "..";
 import { constrainedTypeKind, type ConstraintHandler } from "./constraint";
 import { type Primitive, type EligiblePrimitive } from "./primitive";
 import * as DEither from "../either";
@@ -10,7 +10,7 @@ type _NewType<GenericName extends string, GenericValue extends unknown, GenericC
 export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstraintsName> {
 }
 export declare const newTypeHandlerKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type-handler", unknown>>;
-export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
+export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly ConstraintHandler[], GenericInput extends unknown = unknown> extends Kind<typeof newTypeHandlerKind.definition> {
     /**
      * The NewType name used as the brand (for example "userId").
      * 
@@ -20,7 +20,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * The DataParser used to validate and transform raw inputs.
      * 
      */
-    readonly dataParser: DDataParser.Contract<GenericValue>;
+    readonly dataParser: DDataParser.Contract<GenericValue, unknown>;
     /**
      * The list of constraints applied to this NewType.
      * 
@@ -35,6 +35,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * 
      */
     create<const GenericInput extends GenericValue>(data: GenericInput): (DEither.Right<"createNewType", NewType<GenericName, GenericInput, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create(data: GenericValue): (DEither.Right<"createNewType", NewType<GenericName, GenericInput, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value and throws on error. Works with raw values or primitives.
@@ -51,6 +52,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * 
      */
     createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstraintsHandler[number]["name"]>;
+    createOrThrow(data: GenericInput): NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>;
     createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>);
     /**
      * Creates a NewType value from an unknown input and returns an Either.
@@ -150,9 +152,9 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
 export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstraintsHandler 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>>[]>[]
-]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstraintsHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstraintsHandler, readonly []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstraintsHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstraintsHandler, readonly []>>, IsEqual<DDataParser.Output<GenericDataParser>, DDataParser.Input<GenericDataParser>> extends true ? never : DDataParser.Input<GenericDataParser>>;
 export declare namespace createNewType {
-    var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly []>>;
+    var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[], unknown>[], unknown>>;
 }
 export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constraints"][number]["name"]> : never, any>;
 export {};

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

@@ -1,12 +1,13 @@
-import { type Kind, type WrappedValue } from "../../common";
+import { type IsEqual, type Kind, type WrappedValue } from "../../common";
 import * as DDataParser from "../../dataParser";
 import * as DEither from "../../either";
-export type EligiblePrimitive = string | number | boolean | bigint;
+import type * as DDate from "../../date";
+export type EligiblePrimitive = string | number | boolean | bigint | DDate.TheDate | DDate.TheTime;
 export interface Primitive<GenericValue extends EligiblePrimitive> extends WrappedValue<GenericValue> {
 }
 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>;
+export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = EligiblePrimitive, GenericInput extends unknown = unknown> extends Kind<typeof primitiveHandlerKind.definition> {
+    readonly dataParser: DDataParser.Contract<GenericValue, unknown>;
     /**
      * Creates a primitive value and returns an Either.
      * 
@@ -19,7 +20,8 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
      * ```
      * 
      */
-    create<GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createNewType", Primitive<GenericData>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createPrimitive", Primitive<GenericData>> | DEither.Left<"createPrimitiveError", DDataParser.DataParserError>);
+    create(data: GenericInput): (DEither.Right<"createPrimitive", Primitive<GenericValue>> | DEither.Left<"createPrimitiveError", DDataParser.DataParserError>);
     /**
      * Creates a primitive value and throws on error.
      * 
@@ -30,6 +32,7 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
      * 
      */
     createOrThrow<GenericData extends GenericValue>(data: GenericData): Primitive<GenericData>;
+    createOrThrow(data: GenericInput): Primitive<GenericValue>;
     /**
      * Creates a primitive value from an unknown input and returns an Either.
      * 
@@ -40,7 +43,7 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createNewType", Primitive<GenericValue>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createPrimitive", Primitive<GenericValue>> | DEither.Left<"createPrimitiveError", DDataParser.DataParserError>);
     /**
      * Creates a primitive value from an unknown input and throws on error.
      * 
@@ -73,9 +76,9 @@ export declare class CreatePrimitiveError extends CreatePrimitiveError_base {
     dataParserError: DDataParser.DataParserError;
     constructor(data: unknown, dataParserError: DDataParser.DataParserError);
 }
-export declare function createPrimitive<GenericDataParser extends DDataParser.Contract<EligiblePrimitive>>(dataParser: GenericDataParser): PrimitiveHandler<DDataParser.Output<GenericDataParser>>;
+export declare function createPrimitive<GenericDataParser extends DDataParser.Contract<EligiblePrimitive, unknown>>(dataParser: GenericDataParser): PrimitiveHandler<DDataParser.Output<GenericDataParser>, IsEqual<DDataParser.Output<GenericDataParser>, DDataParser.Input<GenericDataParser>> extends true ? never : DDataParser.Input<GenericDataParser>>;
 export declare namespace createPrimitive {
-    var overrideHandler: import("../../common").OverrideHandler<PrimitiveHandler<EligiblePrimitive>>;
+    var overrideHandler: import("../../common").OverrideHandler<PrimitiveHandler<EligiblePrimitive, unknown>>;
 }
 /**
  * Business primitive for string values.
@@ -108,7 +111,7 @@ export declare namespace createPrimitive {
  * @namespace C
  * 
  */
-export declare const String: PrimitiveHandler<string>;
+export declare const String: PrimitiveHandler<string, never>;
 export type String = ReturnType<typeof String["createWithUnknownOrThrow"]>;
 /**
  * Business primitive for number values.
@@ -141,7 +144,7 @@ export type String = ReturnType<typeof String["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const Number: PrimitiveHandler<number>;
+export declare const Number: PrimitiveHandler<number, never>;
 export type Number = ReturnType<typeof Number["createWithUnknownOrThrow"]>;
 /**
  * Business primitive for bigint values.
@@ -174,7 +177,7 @@ export type Number = ReturnType<typeof Number["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const BigInt: PrimitiveHandler<bigint>;
+export declare const BigInt: PrimitiveHandler<bigint, never>;
 export type BigInt = ReturnType<typeof BigInt["createWithUnknownOrThrow"]>;
 /**
  * Business primitive for boolean values.
@@ -207,34 +210,28 @@ export type BigInt = ReturnType<typeof BigInt["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const Boolean: PrimitiveHandler<boolean>;
+export declare const Boolean: PrimitiveHandler<boolean, never>;
 export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
 /**
- * Business primitive for date values (TheDate).
+ * Business primitive for date values (`TheDate`).
  * 
  * **Supported call styles:**
- * - Classic: `Date.create(value)` -> returns Either
+ * - Classic: `Date.create(value)` → `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.
+ * Use it to keep domain values wrapped instead of passing raw dates through business logic.
  * 
  * ```ts
  * const date = D.create("2024-01-01");
- * 
  * const result = C.Date.create(date);
  * 
  * if (E.isRight(result)) {
- * // result: E.Right<"createNewType", C.Primitive<D.TheDate>>
+ * 	// result: E.Right<"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
@@ -242,23 +239,18 @@ export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const Date: PrimitiveHandler<`date${number}-` | `date${number}+`>;
+export declare const Date: PrimitiveHandler<DDate.TheDate, DDate.TheDate | `date${number}-` | `date${number}+` | globalThis.Date>;
 export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
 /**
- * Business primitive for time values (TheTime).
+ * Business primitive for duration values (`TheTime`).
  * 
  * **Supported call styles:**
- * - Classic: `Time.create(value)` -> returns Either
+ * - Classic: `Time.create(value)` → `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.
+ * Use it to keep normalized time values wrapped in the domain layer.
  * 
  * ```ts
- * const theTime = D.createTheTime(3_600_000);
- * 
+ * const theTime = D.createTime(1, "hour");
  * const result = C.Time.create(theTime);
  * 
  * if (E.isRight(result)) {
@@ -269,7 +261,6 @@ export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
  * // value: C.Primitive<D.TheTime>
  * 
  * C.Time.is(value); // type guard
- * 
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/clean/primitives
@@ -277,7 +268,7 @@ export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const Time: PrimitiveHandler<`time${number}-` | `time${number}+`>;
+export declare const Time: PrimitiveHandler<DDate.TheTime, number | DDate.TheTime | `time${number}-` | `time${number}+`>;
 export type Time = ReturnType<typeof Time["createWithUnknownOrThrow"]>;
 export type Primitives = (String | Number | BigInt | Boolean | Date | Time);
 export type PrimitiveHandlers = (typeof String | typeof Number | typeof BigInt | typeof Boolean | typeof Date | typeof Time);

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

@@ -1,33 +1,29 @@
 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.
+ * Adds a duration to a wrapped `Date` and returns a wrapped `Date`.
  * 
  * **Supported call styles:**
- * - Classic: `dateAddTime(date, time)` -> returns a Date
- * - Curried: `dateAddTime(time)` -> returns a function waiting for the date
+ * - Classic: `dateAddTime(date, time)` → `Date`
+ * - Curried: `dateAddTime(time)` → function waiting for the date
  * 
- * Use it to move dates forward while keeping values wrapped.
+ * `time` accepts wrapped `Time` or raw `TheTime`.
  * 
  * ```ts
  * const date = C.Date.createOrThrow(D.create("2024-01-01"));
- * const oneHour = C.Time.createOrThrow(D.createTheTime(3_600_000));
+ * const oneHour = C.Time.createOrThrow(D.createTime(1, "hour"));
  * 
  * const later = C.dateAddTime(date, oneHour);
  * // later: C.Date
  * 
  * const curried = pipe(
  * 	date,
- * 	C.dateAddTime(D.createTheTime(60_000)),
+ * 	C.dateAddTime(D.createTime(1, "minute")),
  * );
  * // curried: C.Date
  * 
- * const mixed = C.dateAddTime(
- * 	C.Date.createOrThrow(D.create("2024-01-02")),
- * 	D.createTheTime(500),
- * );
+ * const mixed = C.dateAddTime(date, D.createTime(500, "millisecond"));
  * // mixed: C.Date
- * 
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateAddTime

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

@@ -1,22 +1,24 @@
 import { type Date } from "../../base";
 import { type TheDate } from "../../../../date";
 /**
- * Checks whether a Date is after a threshold.
+ * Checks whether a wrapped `Date` is strictly after a threshold.
  * 
  * **Supported call styles:**
- * - Classic: `dateGreaterThan(date, threshold)` -> returns a boolean
- * - Curried: `dateGreaterThan(threshold)` -> returns a function waiting for the date
+ * - Classic: `dateGreaterThan(date, threshold)` → `boolean`
+ * - Curried: `dateGreaterThan(threshold)` → function waiting for the date
  * 
- * Use it to compare wrapped dates or raw TheDate values.
+ * `threshold` accepts wrapped `Date` or raw `TheDate`.
  * 
  * ```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
- * }
+ * const result = C.dateGreaterThan(date, threshold);
+ * // result: true
  * 
+ * pipe(
+ * 	date,
+ * 	C.dateGreaterThan(threshold),
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateGreaterThan