@duplojs/utils 1.4.56 → 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.cjs

@@ -2,16 +2,15 @@
 
 var kind = require('./kind.cjs');
 var newType = require('./newType.cjs');
+var asserts = require('../common/asserts.cjs');
 var kind$1 = require('../common/kind.cjs');
 var pipe = require('../common/pipe.cjs');
-var filter = require('../array/filter.cjs');
-var isType = require('../common/isType.cjs');
 var map = require('../array/map.cjs');
-var entry = require('../object/entry.cjs');
 var toTuple = require('../array/toTuple.cjs');
 var first = require('../array/at/first.cjs');
 var innerPipe = require('../common/innerPipe.cjs');
 var when = require('../pattern/when.cjs');
+var isType = require('../common/isType.cjs');
 var exhaustive = require('../pattern/exhaustive.cjs');
 var when$1 = require('../common/when.cjs');
 var index = require('../dataParser/parsers/array/index.cjs');
@@ -24,13 +23,12 @@ var entries = require('../object/entries.cjs');
 var forward = require('../common/forward.cjs');
 var errorKindNamespace = require('../common/errorKindNamespace.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
+var entry = require('../object/entry.cjs');
 var transform = require('../dataParser/parsers/transform.cjs');
 var base$1 = require('./constraint/base.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
-var otherwise = require('../pattern/otherwise.cjs');
-var justReturn = require('../common/justReturn.cjs');
-var union = require('../dataParser/parsers/union.cjs');
 var minElements = require('../array/minElements.cjs');
+var union = require('../dataParser/parsers/union.cjs');
 var index$1 = require('../dataParser/parsers/object/index.cjs');
 var override = require('../common/override.cjs');
 var is = require('../either/left/is.cjs');
@@ -61,7 +59,10 @@ function createEntity(name, getPropertiesDefinition) {
         return transform.transform(simplePropertyDefinition.dataParser, (value) => base$1.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
     }
     function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {
-        return pipe.pipe(unionPropertyDefinition, map.map(simplePropertyDefinitionToDataParser), when.when(minElements.minElements(1), union.union), otherwise.otherwise(justReturn.justReturn(null)));
+        return pipe.pipe(unionPropertyDefinition, map.map(simplePropertyDefinitionToDataParser), (options) => {
+            asserts.asserts(options, minElements.minElements(1));
+            return union.union(options);
+        });
     }
     const params = {
         union: (...type) => ({ type }),
@@ -99,7 +100,7 @@ function createEntity(name, getPropertiesDefinition) {
             }
             return dataParser;
         }, when$1.when(() => definition.nullable === true, nullable.nullable))))), exhaustive.exhaustive),
-    ])), map.map(([key, value]) => value !== null && entry.entry(key, value)), filter.filter(isType.isType("array")), fromEntries.fromEntries, index$1.object, (dataParser) => transform.transform(dataParser, (value) => entityKind.setTo(value, name)));
+    ])), fromEntries.fromEntries, index$1.object, (dataParser) => transform.transform(dataParser, (value) => entityKind.setTo(value, name)));
     function map$1(rawProperties) {
         const result = mapDataParser.parse(rawProperties);
         if (is.isLeft(result)) {

package/dist/clean/entity.d.ts

@@ -27,7 +27,14 @@ export type EntityProperties<GenericPropertiesDefinition extends EntityPropertie
     ] : readonly InferredValue[] : InferredValue) extends infer InferredValueWithArray ? IsEqual<GenericPropertiesDefinition[Prop]["nullable"], true> extends true ? InferredValueWithArray | null : InferredValueWithArray : never : never : unknown);
 }>;
 export type EntityRawProperties<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 ? 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 ? (IsEqual<GenericPropertiesDefinition[Prop]["inArray"], true> extends true ? readonly InferredValue[] : GenericPropertiesDefinition[Prop]["inArray"] extends object ? GenericPropertiesDefinition[Prop]["inArray"]["min"] extends number ? readonly [
+        ...DArray.CreateTuple<InferredValue, GenericPropertiesDefinition[Prop]["inArray"]["min"]>,
+        ...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 ? 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);
@@ -47,11 +54,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * 
      */
     readonly propertiesDefinition: GenericPropertiesDefinition;
-    /**
-     * The DataParser derived from the properties definition. Useful to reuse validation outside entity creation.
-     * 
-     */
-    readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, EntityRawProperties<GenericPropertiesDefinition>>;
+    readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, unknown>;
     /**
      * Builds an entity from already typed properties.
      * 
@@ -70,7 +73,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      */
     "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
     /**
-     * Validates raw properties and returns an Either with the typed entity.
+     * Validates permissive raw properties and returns an Either with the typed entity.
      * 
      * ```ts
      * if (User.Entity.is(result)) {
@@ -85,9 +88,9 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * ```
      * 
      */
-    map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.Right<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.Left<"createEntityError", DDataParser.DataParserError>);
+    map(rawProperties: PropertiesToMapOfEntity<GenericPropertiesDefinition>): (DEither.Right<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.Left<"createEntityError", DDataParser.DataParserError>);
     /**
-     * Validates raw properties and throws on error.
+     * Validates permissive raw properties and throws on error.
      * 
      * ```ts
      * const mapped = User.Entity.mapOrThrow({
@@ -99,7 +102,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * ```
      * 
      */
-    mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
+    mapOrThrow(rawProperties: PropertiesToMapOfEntity<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
     /**
     * Checks if a value is an entity of this handler (type guard).
     * 
@@ -129,9 +132,9 @@ declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;
 }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../common").KindDefinition<"create-entity-error", unknown>, unknown> & Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-entity-error", unknown>, unknown>;
 export declare class CreateEntityError extends CreateEntityError_base {
-    rawProperties: EntityRawProperties;
+    rawProperties: PropertiesToMapOfEntity;
     dataParserError: DDataParser.DataParserError;
-    constructor(rawProperties: EntityRawProperties, dataParserError: DDataParser.DataParserError);
+    constructor(rawProperties: PropertiesToMapOfEntity, dataParserError: DDataParser.DataParserError);
 }
 export interface PropertiesDefinitionParams {
     union<const GenericUnionPropertyDefinition extends EntityUnionPropertyDefinition>(...type: GenericUnionPropertyDefinition): {
@@ -216,7 +219,7 @@ export interface PropertiesDefinitionParams {
  * 
  * @remarks
  * - The definition callback can use helpers like `array`, `nullable`, and `union` to enrich properties.
- * - Use `map`/`mapOrThrow` to build from raw inputs; `new` expects already typed values.
+ * - Use `map`/`mapOrThrow` to build from raw inputs (with runtime constraint checks); `new` expects already typed values.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/clean/entity
  * 

package/dist/clean/entity.mjs

@@ -1,15 +1,14 @@
 import { createCleanKind } from './kind.mjs';
 import { newTypeHandlerKind, newTypeKind } from './newType.mjs';
+import { asserts } from '../common/asserts.mjs';
 import { kindHeritage } from '../common/kind.mjs';
 import { pipe } from '../common/pipe.mjs';
-import { filter } from '../array/filter.mjs';
-import { isType } from '../common/isType.mjs';
 import { map } from '../array/map.mjs';
-import { entry } from '../object/entry.mjs';
 import { toTuple } from '../array/toTuple.mjs';
 import { first } from '../array/at/first.mjs';
 import { innerPipe } from '../common/innerPipe.mjs';
 import { when } from '../pattern/when.mjs';
+import { isType } from '../common/isType.mjs';
 import { exhaustive } from '../pattern/exhaustive.mjs';
 import { when as when$1 } from '../common/when.mjs';
 import { array } from '../dataParser/parsers/array/index.mjs';
@@ -22,13 +21,12 @@ import { entries } from '../object/entries.mjs';
 import { forward } from '../common/forward.mjs';
 import { createErrorKind } from '../common/errorKindNamespace.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
+import { entry } from '../object/entry.mjs';
 import { transform } from '../dataParser/parsers/transform.mjs';
 import { constrainedTypeKind } from './constraint/base.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
-import { otherwise } from '../pattern/otherwise.mjs';
-import { justReturn } from '../common/justReturn.mjs';
-import { union } from '../dataParser/parsers/union.mjs';
 import { minElements } from '../array/minElements.mjs';
+import { union } from '../dataParser/parsers/union.mjs';
 import { object } from '../dataParser/parsers/object/index.mjs';
 import { createOverride } from '../common/override.mjs';
 import { isLeft } from '../either/left/is.mjs';
@@ -59,7 +57,10 @@ function createEntity(name, getPropertiesDefinition) {
         return transform(simplePropertyDefinition.dataParser, (value) => constrainedTypeKind.setTo(newTypeKind.setTo(wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
     }
     function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {
-        return pipe(unionPropertyDefinition, map(simplePropertyDefinitionToDataParser), when(minElements(1), union), otherwise(justReturn(null)));
+        return pipe(unionPropertyDefinition, map(simplePropertyDefinitionToDataParser), (options) => {
+            asserts(options, minElements(1));
+            return union(options);
+        });
     }
     const params = {
         union: (...type) => ({ type }),
@@ -97,7 +98,7 @@ function createEntity(name, getPropertiesDefinition) {
             }
             return dataParser;
         }, when$1(() => definition.nullable === true, nullable))))), exhaustive),
-    ])), map(([key, value]) => value !== null && entry(key, value)), filter(isType("array")), fromEntries, object, (dataParser) => transform(dataParser, (value) => entityKind.setTo(value, name)));
+    ])), fromEntries, object, (dataParser) => transform(dataParser, (value) => entityKind.setTo(value, name)));
     function map$1(rawProperties) {
         const result = mapDataParser.parse(rawProperties);
         if (isLeft(result)) {

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 {};