@duplojs/utils 1.4.53 → 1.4.55

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

@@ -30,9 +30,17 @@ function NumberMin(value) {
 function NumberMax(value) {
     return base.createConstraint(`number-max-${value}`, base$1.Number, max.checkerNumberMax(value));
 }
+/**
+ * {@include clean/PositiveInt/index.md}
+ */
+const PositiveInt = base.createConstraint("positive-int", base$1.Number, [
+    int.checkerInt(),
+    min.checkerNumberMin(1),
+]);
 
 exports.Int = Int;
 exports.Negative = Negative;
 exports.NumberMax = NumberMax;
 exports.NumberMin = NumberMin;
 exports.Positive = Positive;
+exports.PositiveInt = PositiveInt;

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

@@ -148,3 +148,32 @@ export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin
  */
 export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax]>;
 export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax<GenericValue>>;
+/**
+ * Constraint handler that validates strictly positive integers (>= 1).
+ * 
+ * **Supported call styles:**
+ * - Classic: `PositiveInt.create(value)` -> returns Either
+ * 
+ * Use it as a reusable rule to validate inputs and to constrain NewTypes to positive integer numbers.
+ * 
+ * ```ts
+ * const result = C.PositiveInt.create(4);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"positive-int", 4>>
+ * }
+ * 
+ * const value = C.PositiveInt.createOrThrow(10);
+ * // value: C.ConstrainedType<"positive-int", 10>
+ * 
+ * C.PositiveInt.is(value); // type guard
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare const PositiveInt: import("..").ConstraintHandler<"positive-int", number, readonly [DDataParser.DataParserCheckerInt, DDataParser.DataParserCheckerNumberMin]>;
+export type PositiveInt = GetConstraint<typeof PositiveInt>;

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

@@ -28,5 +28,12 @@ function NumberMin(value) {
 function NumberMax(value) {
     return createConstraint(`number-max-${value}`, Number, checkerNumberMax(value));
 }
+/**
+ * {@include clean/PositiveInt/index.md}
+ */
+const PositiveInt = createConstraint("positive-int", Number, [
+    checkerInt(),
+    checkerNumberMin(1),
+]);
 
-export { Int, Negative, NumberMax, NumberMin, Positive };
+export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt };

package/dist/clean/constraint/set.cjs

@@ -79,7 +79,7 @@ function createConstraintsSet(primitiveHandler, constraint) {
     }
     return pipe.pipe({
         primitiveHandler,
-        constrains: constraints,
+        constraints,
         getConstraint,
         create: create$2,
         createOrThrow,

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, GenericConstrainsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof constraintsSetHandlerKind.definition> {
+export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof constraintsSetHandlerKind.definition> {
     /**
      * The primitive handler used to validate and wrap values (e.g. `C.String`, `C.Number`).
      * 
@@ -15,7 +15,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * The list of constraint handlers applied by this set.
      * 
      */
-    readonly constrains: GenericConstrainsHandler;
+    readonly constraints: GenericConstraintsHandler;
     /**
      * Creates a constrained value and returns an Either.
      * 
@@ -28,8 +28,8 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    create<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[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<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    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<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.
      * 
@@ -42,8 +42,8 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    createOrThrow<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
-    createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    createOrThrow<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (Primitive<GenericInput> & 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.
      * 
@@ -53,7 +53,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
     /**
      * Creates a constrained value from an unknown input and throws on error.
      * 
@@ -62,7 +62,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
     /**
      * Checks if a value satisfies all constraints of the set (type guard).
      * 
@@ -71,7 +71,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)>;
     /**
      * Returns a constraint handler by name from the constraints set.
      * 
@@ -81,7 +81,7 @@ export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePri
      * ```
      * 
      */
-    getConstraint<GenericConstraintName extends GenericConstrainsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstrainsHandler[number], ConstraintHandler<GenericConstraintName>>;
+    getConstraint<GenericConstraintName extends GenericConstraintsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstraintsHandler[number], ConstraintHandler<GenericConstraintName>>;
 }
 declare const CreateConstraintsSetError_base: new (params: {
     "@DuplojsUtilsError/create-constraint-set-error"?: unknown;
@@ -143,5 +143,5 @@ export declare function createConstraintsSet<GenericPrimitiveValue extends Eligi
 export declare namespace createConstraintsSet {
     var overrideHandler: import("../..").OverrideHandler<ConstraintsSetHandler<EligiblePrimitive, readonly []>>;
 }
-export type GetConstraints<GenericHandler extends ConstraintsSetHandler<EligiblePrimitive, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["constrains"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
+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/constraint/set.mjs

@@ -77,7 +77,7 @@ function createConstraintsSet(primitiveHandler, constraint) {
     }
     return pipe({
         primitiveHandler,
-        constrains: constraints,
+        constraints,
         getConstraint,
         create,
         createOrThrow,

package/dist/clean/entity.cjs

@@ -57,7 +57,7 @@ function createEntity(name, getPropertiesDefinition) {
         return entityKind.addTo(properties, name);
     }
     function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
-        const constraintKindValue = pipe.pipe(simplePropertyDefinition.constrains, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+        const constraintKindValue = pipe.pipe(simplePropertyDefinition.constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
         return transform.transform(simplePropertyDefinition.dataParser, (value) => base$1.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
     }
     function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {

package/dist/clean/entity.mjs

@@ -55,7 +55,7 @@ function createEntity(name, getPropertiesDefinition) {
         return entityKind.addTo(properties, name);
     }
     function simplePropertyDefinitionToDataParser(simplePropertyDefinition) {
-        const constraintKindValue = pipe(simplePropertyDefinition.constrains, map(({ name }) => entry(name, null)), fromEntries);
+        const constraintKindValue = pipe(simplePropertyDefinition.constraints, map(({ name }) => entry(name, null)), fromEntries);
         return transform(simplePropertyDefinition.dataParser, (value) => constrainedTypeKind.setTo(newTypeKind.setTo(wrapValue(value), simplePropertyDefinition.name), constraintKindValue));
     }
     function unionPropertyDefinitionToDataParser(unionPropertyDefinition) {

package/dist/clean/index.cjs

@@ -7,6 +7,7 @@ var repository = require('./repository.cjs');
 var useCase = require('./useCase.cjs');
 var flag = require('./flag.cjs');
 var unwrapEntity = require('./unwrapEntity.cjs');
+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');
@@ -58,6 +59,8 @@ exports.useCaseInstances = useCase.useCaseInstances;
 exports.createFlag = flag.createFlag;
 exports.flagKind = flag.flagKind;
 exports.unwrapEntity = unwrapEntity.unwrapEntity;
+exports.none = maybe.none;
+exports.some = maybe.some;
 exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
 exports.constrainedTypeKind = base.constrainedTypeKind;
 exports.constraintHandlerKind = base.constraintHandlerKind;
@@ -67,6 +70,7 @@ exports.Negative = number.Negative;
 exports.NumberMax = number.NumberMax;
 exports.NumberMin = number.NumberMin;
 exports.Positive = number.Positive;
+exports.PositiveInt = number.PositiveInt;
 exports.Email = string.Email;
 exports.StringMax = string.StringMax;
 exports.StringMin = string.StringMin;

package/dist/clean/index.d.ts

@@ -33,3 +33,4 @@ export * from "./repository";
 export * from "./useCase";
 export * from "./flag";
 export * from "./unwrapEntity";
+export * from "./maybe";

package/dist/clean/index.mjs

@@ -5,8 +5,9 @@ export { createRepository, repositoryHandlerKind } from './repository.mjs';
 export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
 export { createFlag, flagKind } from './flag.mjs';
 export { unwrapEntity } from './unwrapEntity.mjs';
+export { none, some } from './maybe.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
-export { Int, Negative, NumberMax, NumberMin, Positive } from './constraint/defaultConstraint/number.mjs';
+export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt } from './constraint/defaultConstraint/number.mjs';
 export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';
 export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet } from './constraint/set.mjs';
 export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind } from './primitive/base.mjs';

package/dist/clean/maybe.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var entity = require('./entity.cjs');
+var create = require('../either/right/create.cjs');
+var create$1 = require('../either/left/create.cjs');
+
+/**
+ * {@include clean/some/index.md}
+ */
+function some(entity$1) {
+    return create.right(`some-${entity.entityKind.getValue(entity$1)}`, entity$1);
+}
+/**
+ * {@include clean/none/index.md}
+ */
+function none(entityName) {
+    return create$1.left(`none-${entityName}`, null);
+}
+
+exports.none = none;
+exports.some = some;

package/dist/clean/maybe.d.ts

@@ -0,0 +1,135 @@
+import * as DEither from "../either";
+import { type Entity, entityKind } from "./entity";
+import { type GetKindValue } from "../common";
+export interface Some<GenericEntity extends Entity = Entity> extends DEither.Right<`some-${GetKindValue<typeof entityKind, GenericEntity>}`, GenericEntity> {
+}
+export interface None<GenericEntityName extends string = string> extends DEither.Left<`none-${GenericEntityName}`, null> {
+}
+/**
+ * Union type that represents an optional entity in business flows.
+ * 
+ * **Supported usage style:**
+ * - Type contract: `Maybe<Entity>`
+ * 
+ * Use `Maybe` to define a business contract before implementation details. Then produce values with `some(entity)` when data exists, or `none(entityName)` when it does not.
+ * 
+ * ```ts
+ * const UserId = C.createNewType("userId", DPE.number());
+ * const User = C.createEntity("User", () => ({
+ * 	id: UserId,
+ * }));
+ * 
+ * type UserMaybe = C.Maybe<
+ * 	C.GetEntity<typeof User>
+ * >;
+ * 
+ * const availableUser = User.new({
+ * 	id: UserId.createOrThrow(1 as number),
+ * });
+ * 
+ * const foundUser: UserMaybe = C.some(availableUser);
+ * const missingUser: UserMaybe = C.none("User");
+ * 
+ * type checkFound = ExpectType<
+ * 	typeof foundUser,
+ * 	C.Some<typeof availableUser>,
+ * 	"strict"
+ * >;
+ * 
+ * type checkMissing = ExpectType<
+ * 	typeof missingUser,
+ * 	C.None<"User">,
+ * 	"strict"
+ * >;
+ * ```
+ * 
+ * @remarks
+ * `Maybe` helps keep use-case signatures explicit: a function can return a typed optional entity without exposing null/undefined at the domain boundary.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/maybe
+ * 
+ * @namespace C
+ * 
+ */
+export type Maybe<GenericEntity extends Entity = Entity> = (Some<GenericEntity> | None<GetKindValue<typeof entityKind, GenericEntity>>);
+/**
+ * Constructor that creates a `Maybe` success branch from an entity.
+ * 
+ * **Supported call styles:**
+ * - Classic: `some(entity)` -> returns `Some<Entity>`
+ * - Pipe-compatible: `pipe(entity, some)`
+ * 
+ * Use `some` when the expected entity is available and must satisfy a `Maybe<Entity>` contract.
+ * 
+ * ```ts
+ * const UserId = C.createNewType("userId", DPE.number());
+ * const User = C.createEntity("User", () => ({
+ * 	id: UserId,
+ * }));
+ * 
+ * const firstUser = User.new({
+ * 	id: UserId.createOrThrow(1),
+ * });
+ * const firstMaybe = C.some(firstUser);
+ * // firstMaybe: C.Some<typeof firstUser>
+ * 
+ * const secondUser = User.new({
+ * 	id: UserId.createOrThrow(2),
+ * });
+ * const secondMaybe = C.some(secondUser);
+ * // secondMaybe: C.Some<typeof secondUser>
+ * 
+ * const pipedMaybe = pipe(
+ * 	firstUser,
+ * 	C.some,
+ * );
+ * 
+ * type check = ExpectType<
+ * 	typeof pipedMaybe,
+ * 	C.Some<typeof firstUser>,
+ * 	"strict"
+ * >;
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/maybe
+ * 
+ * @namespace C
+ * 
+ */
+export declare function some<GenericEntity extends Entity>(entity: GenericEntity): Some<GenericEntity>;
+/**
+ * Constructor that creates a `Maybe` empty branch from an entity name.
+ * 
+ * **Supported call styles:**
+ * - Classic: `none(entityName)` -> returns `None<entityName>`
+ * - Pipe-compatible: `pipe(entityName, none)`
+ * 
+ * Use `none` when an entity is absent but you still want to keep a precise business contract with `Maybe<Entity>`.
+ * 
+ * ```ts
+ * const noUser = C.none("User");
+ * // noUser: C.None<"User">
+ * 
+ * const noOrder = C.none("Order");
+ * // noOrder: C.None<"Order">
+ * 
+ * const pipedNone = pipe(
+ * 	"Invoice",
+ * 	C.none,
+ * );
+ * 
+ * type check = ExpectType<
+ * 	typeof pipedNone,
+ * 	C.None<"Invoice">,
+ * 	"strict"
+ * >;
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/maybe
+ * 
+ * @namespace C
+ * 
+ */
+export declare function none<GenericEntityName extends string>(entityName: GenericEntityName): None<GenericEntityName>;

package/dist/clean/maybe.mjs

@@ -0,0 +1,18 @@
+import { entityKind } from './entity.mjs';
+import { right } from '../either/right/create.mjs';
+import { left } from '../either/left/create.mjs';
+
+/**
+ * {@include clean/some/index.md}
+ */
+function some(entity) {
+    return right(`some-${entityKind.getValue(entity)}`, entity);
+}
+/**
+ * {@include clean/none/index.md}
+ */
+function none(entityName) {
+    return left(`none-${entityName}`, null);
+}
+
+export { none, some };

package/dist/clean/newType.cjs

@@ -84,7 +84,7 @@ function createNewType(name, dataParser, constraint) {
     return pipe.pipe({
         name,
         dataParser: dataParserWithCheckers,
-        constrains: constraints,
+        constraints,
         getConstraint,
         create: create$2,
         createOrThrow,

package/dist/clean/newType.d.ts

@@ -25,7 +25,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * The list of constraints applied to this NewType.
      * 
      */
-    readonly constrains: GenericConstraintsHandler;
+    readonly constraints: GenericConstraintsHandler;
     /**
      * Creates a NewType value and returns an Either.
      * 
@@ -154,5 +154,5 @@ export declare function createNewType<GenericName extends string, GenericDataPar
 export declare namespace createNewType {
     var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly []>>;
 }
-export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constrains"][number]["name"]> : never, any>;
+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/newType.mjs

@@ -82,7 +82,7 @@ function createNewType(name, dataParser, constraint) {
     return pipe({
         name,
         dataParser: dataParserWithCheckers,
-        constrains: constraints,
+        constraints,
         getConstraint,
         create,
         createOrThrow,

package/dist/dataParser/base.d.ts

@@ -239,8 +239,8 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
     isAsynchronous(): boolean;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
-    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
-    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
+    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
     isAsynchronous(self: GenericDataParser): boolean;
 }
 declare const DataParserThrowError_base: new (params: {

package/dist/metadata.json

@@ -967,6 +967,15 @@
         {
           "name": "kind.mjs"
         },
+        {
+          "name": "maybe.cjs"
+        },
+        {
+          "name": "maybe.d.ts"
+        },
+        {
+          "name": "maybe.mjs"
+        },
         {
           "name": "newType.cjs"
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.53",
+  "version": "1.4.55",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"