@duplojs/utils 1.4.57 → 1.4.59

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

@@ -23,17 +23,20 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
      * Ensures the time is greater than the provided minimum.
      * 
      * ```ts
-     * const parser = DPE.time().min("time0+");
+     * const timeMin = D.createTime(0, "millisecond");
+     * const timeMax = D.createTime(100, "millisecond");
+     * 
+     * const parser = DPE.time().min(timeMin);
      * const result = parser.parse("time10+");
      * if (E.isRight(result)) {
      * 	const value = unwrap(result);
      * 	// value: TheTime
      * }
      * 
-     * const withMessage = DPE.time().min("time0+", { errorMessage: "time.too-small" });
+     * const withMessage = DPE.time().min(timeMin, { errorMessage: "time.too-small" });
      * const messageResult = withMessage.parse("time0+");
      * 
-     * const chained = DPE.time().min("time0+").max("time100+");
+     * const chained = DPE.time().min(timeMin).max(timeMax);
      * const chainedResult = chained.parse("time10+");
      * ```
      * 
@@ -52,17 +55,20 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
      * Ensures the time is smaller than the provided maximum.
      * 
      * ```ts
-     * const parser = DPE.time().max("time100+");
+     * const timeMax = D.createTime(1, "second");
+     * const timeMin = D.createTime(0, "millisecond");
+     * 
+     * const parser = DPE.time().max(timeMax);
      * const result = parser.parse("time10+");
      * if (E.isRight(result)) {
      * 	const value = unwrap(result);
      * 	// value: TheTime
      * }
      * 
-     * const withMessage = DPE.time().max("time100+", { errorMessage: "time.too-large" });
+     * const withMessage = DPE.time().max(timeMax, { errorMessage: "time.too-large" });
      * const messageResult = withMessage.parse("time100+");
      * 
-     * const chained = DPE.time().min("time0+").max("time100+");
+     * const chained = DPE.time().min(timeMin).max(timeMax);
      * const chainedResult = chained.parse("time10+");
      * ```
      * 
@@ -74,15 +80,19 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
     max(max: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMax, "max">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerTimeMax]>>;
 }
 /**
- * Creates an extended data parser for TheTime values.
+ * Creates an extended parser for `TheTime` with chainable time-specific helpers.
  * 
- * **Supported call styles:**
- * - Method: `DPE.time(definition?)` -> returns a time parser
+ * Signature: `DPE.time(definition?)` → `DataParserTimeExtended`
  * 
- * Validates TheTime values and exposes time-specific methods like min and max.
+ * This parser extends the classic time parser behavior and adds fluent methods like `.min(...)` and `.max(...)`.
  * 
  * ```ts
- * const parser = DPE.time().min("time0+").max("time100+");
+ * const minTime = D.createTime(0, "millisecond");
+ * const maxTime = D.createTime(10000, "millisecond");
+ * 
+ * const parser = DPE.time()
+ * 	.min(minTime)
+ * 	.max(maxTime);
  * const result = parser.parse("time10+");
  * if (E.isRight(result)) {
  * 	const value = unwrap(result);
@@ -91,11 +101,17 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
  * 
  * const coerceParser = DPE.coerce.time();
  * const coerceResult = coerceParser.parse("10:20:00");
+ * // E.Error<DPE.DataParserError> | E.Success<D.TheTime>
  * 
- * const minOnly = DPE.time().min("time0+");
+ * const minOnly = DPE.time().min(minTime);
  * const minResult = minOnly.parse("time0+");
+ * // E.Error<DPE.DataParserError> | E.Success<D.TheTime>
  * ```
  * 
+ * @remarks
+ * - `.min(...)` and `.max(...)` expect `TheTime` values.
+ * - `DPE.coerce.time()` enables the same coercion flow as classic parser mode.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
  * 
  * @namespace DPE

package/dist/dataParser/identifier.d.ts

@@ -42,11 +42,11 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `date${number}-` | `date${number}+`;
-        output: `date${number}-` | `date${number}+`;
+        input: import("../date").TheDate | `date${number}-` | `date${number}+` | Date;
+        output: import("../date").TheDate;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `time${number}-` | `time${number}+`;
-        output: `time${number}-` | `time${number}+`;
+        input: number | import("../date").TheTime | `time${number}-` | `time${number}+`;
+        output: import("../date").TheTime;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
         output: null;
@@ -59,6 +59,12 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: import("../date").TheDate;
+        output: import("../date").TheDate;
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: import("../date").TheTime;
+        output: import("../date").TheTime;
     }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
     <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
@@ -94,11 +100,11 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `date${number}-` | `date${number}+`;
-        output: `date${number}-` | `date${number}+`;
+        input: import("../date").TheDate | `date${number}-` | `date${number}+` | Date;
+        output: import("../date").TheDate;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `time${number}-` | `time${number}+`;
-        output: `time${number}-` | `time${number}+`;
+        input: number | import("../date").TheTime | `time${number}-` | `time${number}+`;
+        output: import("../date").TheTime;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
         output: null;
@@ -111,5 +117,11 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: import("../date").TheDate;
+        output: import("../date").TheDate;
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: import("../date").TheTime;
+        output: import("../date").TheTime;
     }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/dataParser/parsers/date.cjs

@@ -4,8 +4,9 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 var isSafeTimestamp = require('../../date/isSafeTimestamp.cjs');
-var createTheDate = require('../../date/createTheDate.cjs');
-var is = require('../../date/is.cjs');
+var theDate = require('../../date/theDate.cjs');
+var isSerializedTheDate = require('../../date/isSerializedTheDate.cjs');
+var toTimestamp = require('../../date/toTimestamp.cjs');
 var override = require('../../common/override.cjs');
 
 const dateKind = kind.createDataParserKind("date");
@@ -19,30 +20,33 @@ function date(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
-            if (data instanceof Date) {
-                const timestamp = data.getTime();
-                if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
-                    return error.SymbolDataParserErrorIssue;
-                }
-                return createTheDate.createTheDate(timestamp);
-            }
             if (typeof data === "number") {
                 if (!isSafeTimestamp.isSafeTimestamp(data)) {
                     return error.SymbolDataParserErrorIssue;
                 }
-                return createTheDate.createTheDate(data);
+                return theDate.TheDate.new(data);
             }
             if (typeof data === "string") {
                 const date = new Date(data);
                 const timestamp = date.getTime();
                 if (isSafeTimestamp.isSafeTimestamp(timestamp)) {
-                    return createTheDate.createTheDate(timestamp);
+                    return theDate.TheDate.new(timestamp);
                 }
             }
         }
-        if (typeof data === "string" && is.is(data)) {
+        if (data instanceof theDate.TheDate) {
             return data;
         }
+        else if (typeof data === "string" && isSerializedTheDate.isSerializedTheDate(data)) {
+            return theDate.TheDate.new(toTimestamp.toTimestamp(data));
+        }
+        else if (data instanceof Date) {
+            const timestamp = data.getTime();
+            if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            return theDate.TheDate.new(timestamp);
+        }
         return error.SymbolDataParserErrorIssue;
     }, date.overrideHandler);
     return self;

package/dist/dataParser/parsers/date.d.ts

@@ -3,15 +3,15 @@ import { type DataParserDefinition, type DataParser, type DataParserChecker } fr
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type CheckerRefineImplementation } from "./refine";
 import { type GetPropsWithValueExtends } from "../../object";
-import { type TheDate } from "../../date";
+import * as DDate from "../../date";
 export interface DataParserDateCheckerCustom {
 }
-export type DataParserDateCheckers = (DataParserDateCheckerCustom[GetPropsWithValueExtends<DataParserDateCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<TheDate>);
+export type DataParserDateCheckers = (DataParserDateCheckerCustom[GetPropsWithValueExtends<DataParserDateCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<DDate.TheDate>);
 export interface DataParserDefinitionDate extends DataParserDefinition<DataParserDateCheckers> {
     readonly coerce: boolean;
 }
 export declare const dateKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>>;
-type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, TheDate, TheDate> & Kind<typeof dateKind.definition>);
+type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, DDate.TheDate, DDate.TheDate | Date | DDate.SerializedTheDate> & Kind<typeof dateKind.definition>);
 export interface DataParserDate<GenericDefinition extends DataParserDefinitionDate = DataParserDefinitionDate> extends _DataParserDate<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserDateCheckers,
@@ -22,13 +22,12 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
     ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 /**
- * Creates a data parser for TheDate values.
+ * Creates a classic parser for `TheDate` values.
  * 
- * **Supported call styles:**
- * - Classic: `DP.date(definition?)` -> returns a date parser
- * - Curried: not available
+ * Signature: `DP.date(definition?)` → `DataParserDate`
  * 
- * Validates that the input is a TheDate, optionally applies coerce, and runs the configured checkers.
+ * The parser accepts `TheDate`, `SerializedTheDate`, and native `Date`.
+ * With `coerce: true`, safe timestamps and parsable date strings are also supported.
  * 
  * ```ts
  * const parser = DP.date();
@@ -39,13 +38,20 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
  * }
  * 
  * const withCheckers = DP.date({
- * 	checkers: [DP.checkerRefine((value) => value !== "date0+")],
+ * 	checkers: [DP.checkerRefine((value) => value.getUTCFullYear() >= 2024)],
  * });
+ * const checked = withCheckers.parse("date1704067200000+");
+ * // checked: E.Error<DP.DataParserError> | E.Success<TheDate>
  * 
  * const coerceParser = DP.coerce.date();
  * const coerceResult = coerceParser.parse("2024-01-01T00:00:00.000Z");
+ * // coerceResult: E.Error<DP.DataParserError> | E.Success<TheDate>
  * ```
  * 
+ * @remarks
+ * - Parsed output is always `TheDate`.
+ * - Use `DP.coerce.date()` when you want coercion enabled by default.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/date
  * 
  * @namespace DP

package/dist/dataParser/parsers/date.mjs

@@ -2,8 +2,9 @@ import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 import { isSafeTimestamp } from '../../date/isSafeTimestamp.mjs';
-import { createTheDate } from '../../date/createTheDate.mjs';
-import { is } from '../../date/is.mjs';
+import { TheDate } from '../../date/theDate.mjs';
+import { isSerializedTheDate } from '../../date/isSerializedTheDate.mjs';
+import { toTimestamp } from '../../date/toTimestamp.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const dateKind = createDataParserKind("date");
@@ -17,30 +18,33 @@ function date(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
-            if (data instanceof Date) {
-                const timestamp = data.getTime();
-                if (!isSafeTimestamp(timestamp)) {
-                    return SymbolDataParserErrorIssue;
-                }
-                return createTheDate(timestamp);
-            }
             if (typeof data === "number") {
                 if (!isSafeTimestamp(data)) {
                     return SymbolDataParserErrorIssue;
                 }
-                return createTheDate(data);
+                return TheDate.new(data);
             }
             if (typeof data === "string") {
                 const date = new Date(data);
                 const timestamp = date.getTime();
                 if (isSafeTimestamp(timestamp)) {
-                    return createTheDate(timestamp);
+                    return TheDate.new(timestamp);
                 }
             }
         }
-        if (typeof data === "string" && is(data)) {
+        if (data instanceof TheDate) {
             return data;
         }
+        else if (typeof data === "string" && isSerializedTheDate(data)) {
+            return TheDate.new(toTimestamp(data));
+        }
+        else if (data instanceof Date) {
+            const timestamp = data.getTime();
+            if (!isSafeTimestamp(timestamp)) {
+                return SymbolDataParserErrorIssue;
+            }
+            return TheDate.new(timestamp);
+        }
         return SymbolDataParserErrorIssue;
     }, date.overrideHandler);
     return self;

package/dist/dataParser/parsers/time/checkers/max.cjs

@@ -6,6 +6,9 @@ var kind = require('../../../kind.cjs');
 var lessTime = require('../../../../date/operators/lessTime.cjs');
 
 const checkerTimeMaxKind = kind.createDataParserKind("checker-time-max");
+/**
+ * {@include dataParser/classic/checkerTimeMax/index.md}
+ */
 function checkerTimeMax(max, definition = {}) {
     return base.dataParserCheckerInit(checkerTimeMaxKind, {
         definition: {

package/dist/dataParser/parsers/time/checkers/max.d.ts

@@ -8,5 +8,33 @@ export declare const checkerTimeMaxKind: import("../../../../common").KindHandle
 type _DataParserCheckerTimeMax = (Kind<typeof checkerTimeMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionTimeMax, DDate.TheTime>);
 export interface DataParserCheckerTimeMax extends _DataParserCheckerTimeMax {
 }
+/**
+ * Creates a checker that enforces a maximum `TheTime` bound.
+ * 
+ * Signature: `checkerTimeMax(max, definition?)` → `DataParserCheckerTimeMax`
+ * 
+ * The checker passes when parsed value is less than or equal to `max`.
+ * 
+ * ```ts
+ * const parser = DP.time({
+ * 	checkers: [DP.checkerTimeMax(D.createTime(2, "minute"))],
+ * });
+ * 
+ * const valid = parser.parse("time1500+");
+ * // valid: Error<DP.DataParserError> | Success<D.TheTime>
+ * 
+ * const invalid = parser.parse("time2500+");
+ * // invalid: Error<DP.DataParserError> | Success<D.TheTime>
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Designed to be used in `DP.time({ checkers: [...] })` or via `.addChecker(...)`.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function checkerTimeMax(max: DDate.TheTime, definition?: Partial<Omit<DataParserCheckerDefinitionTimeMax, "max">>): DataParserCheckerTimeMax;
 export {};

package/dist/dataParser/parsers/time/checkers/max.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../../kind.mjs';
 import { lessTime } from '../../../../date/operators/lessTime.mjs';
 
 const checkerTimeMaxKind = createDataParserKind("checker-time-max");
+/**
+ * {@include dataParser/classic/checkerTimeMax/index.md}
+ */
 function checkerTimeMax(max, definition = {}) {
     return dataParserCheckerInit(checkerTimeMaxKind, {
         definition: {

package/dist/dataParser/parsers/time/checkers/min.cjs

@@ -6,6 +6,9 @@ var kind = require('../../../kind.cjs');
 var greaterTime = require('../../../../date/operators/greaterTime.cjs');
 
 const checkerTimeMinKind = kind.createDataParserKind("checker-time-min");
+/**
+ * {@include dataParser/classic/checkerTimeMin/index.md}
+ */
 function checkerTimeMin(min, definition = {}) {
     return base.dataParserCheckerInit(checkerTimeMinKind, {
         definition: {

package/dist/dataParser/parsers/time/checkers/min.d.ts

@@ -8,5 +8,33 @@ export declare const checkerTimeMinKind: import("../../../../common").KindHandle
 type _DataParserCheckerTimeMin = (Kind<typeof checkerTimeMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionTimeMin, DDate.TheTime>);
 export interface DataParserCheckerTimeMin extends _DataParserCheckerTimeMin {
 }
+/**
+ * Creates a checker that enforces a minimum `TheTime` bound.
+ * 
+ * Signature: `checkerTimeMin(min, definition?)` → `DataParserCheckerTimeMin`
+ * 
+ * The checker passes when parsed value is greater than or equal to `min`.
+ * 
+ * ```ts
+ * const parser = DP.time({
+ * 	checkers: [DP.checkerTimeMin(D.createTime(1, "minute"))],
+ * });
+ * 
+ * const valid = parser.parse("time1500+");
+ * // valid: Error<DP.DataParserError> | Success<D.TheTime>
+ * 
+ * const invalid = parser.parse("time500+");
+ * // invalid:Error<DP.DataParserError> | Success<D.TheTime>
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Designed to be used in `DP.time({ checkers: [...] })` or via `.addChecker(...)`.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function checkerTimeMin(min: DDate.TheTime, definition?: Partial<Omit<DataParserCheckerDefinitionTimeMin, "min">>): DataParserCheckerTimeMin;
 export {};

package/dist/dataParser/parsers/time/checkers/min.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../../kind.mjs';
 import { greaterTime } from '../../../../date/operators/greaterTime.mjs';
 
 const checkerTimeMinKind = createDataParserKind("checker-time-min");
+/**
+ * {@include dataParser/classic/checkerTimeMin/index.md}
+ */
 function checkerTimeMin(min, definition = {}) {
     return dataParserCheckerInit(checkerTimeMinKind, {
         definition: {

package/dist/dataParser/parsers/time/index.cjs

@@ -3,13 +3,14 @@
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
-var isSafeTimeValue = require('../../../date/isSafeTimeValue.cjs');
-var createTheTime = require('../../../date/createTheTime.cjs');
 var constants = require('../../../date/constants.cjs');
 var createTime = require('../../../date/createTime.cjs');
 var is = require('../../../either/left/is.cjs');
 var unwrap = require('../../../common/unwrap.cjs');
-var isTime = require('../../../date/isTime.cjs');
+var theTime = require('../../../date/theTime.cjs');
+var isSerializedTheTime = require('../../../date/isSerializedTheTime.cjs');
+var toTimeValue = require('../../../date/toTimeValue.cjs');
+var isSafeTimeValue = require('../../../date/isSafeTimeValue.cjs');
 var override = require('../../../common/override.cjs');
 
 const timeKind = kind.createDataParserKind("time");
@@ -23,12 +24,6 @@ function time(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
-            if (typeof data === "number") {
-                if (!isSafeTimeValue.isSafeTimeValue(data)) {
-                    return error.SymbolDataParserErrorIssue;
-                }
-                return createTheTime.createTheTime(data);
-            }
             if (typeof data === "string" && constants.isoTimeRegex.test(data)) {
                 const result = createTime.createTime({ value: data });
                 if (is.isLeft(result)) {
@@ -37,9 +32,18 @@ function time(definition) {
                 return unwrap.unwrap(result);
             }
         }
-        if (typeof data === "string" && isTime.isTime(data)) {
+        if (data instanceof theTime.TheTime) {
             return data;
         }
+        else if (typeof data === "string" && isSerializedTheTime.isSerializedTheTime(data)) {
+            return theTime.TheTime.new(toTimeValue.toTimeValue(data));
+        }
+        else if (typeof data === "number") {
+            if (!isSafeTimeValue.isSafeTimeValue(data)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            return theTime.TheTime.new(data);
+        }
         return error.SymbolDataParserErrorIssue;
     }, time.overrideHandler);
     return self;

package/dist/dataParser/parsers/time/index.d.ts

@@ -3,17 +3,17 @@ import { type DataParserDefinition, type DataParser, type DataParserChecker } fr
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type CheckerRefineImplementation } from "../refine";
 import { type GetPropsWithValueExtends } from "../../../object";
-import { type TheTime } from "../../../date";
+import * as DDate from "../../../date";
 import { type DataParserCheckerTimeMax, type DataParserCheckerTimeMin } from "./checkers";
 export * from "./checkers";
 export interface DataParserTimeCheckerCustom {
 }
-export type DataParserTimeCheckers = (DataParserTimeCheckerCustom[GetPropsWithValueExtends<DataParserTimeCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<TheTime> | DataParserCheckerTimeMax | DataParserCheckerTimeMin);
+export type DataParserTimeCheckers = (DataParserTimeCheckerCustom[GetPropsWithValueExtends<DataParserTimeCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<DDate.TheTime> | DataParserCheckerTimeMax | DataParserCheckerTimeMin);
 export interface DataParserDefinitionTime extends DataParserDefinition<DataParserTimeCheckers> {
     readonly coerce: boolean;
 }
 export declare const timeKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>>;
-type _DataParserTime<GenericDefinition extends DataParserDefinitionTime> = (DataParser<GenericDefinition, TheTime, TheTime> & Kind<typeof timeKind.definition>);
+type _DataParserTime<GenericDefinition extends DataParserDefinitionTime> = (DataParser<GenericDefinition, DDate.TheTime, DDate.TheTime | number | DDate.SerializedTheTime> & Kind<typeof timeKind.definition>);
 export interface DataParserTime<GenericDefinition extends DataParserDefinitionTime = DataParserDefinitionTime> extends _DataParserTime<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserTimeCheckers,
@@ -24,13 +24,12 @@ export interface DataParserTime<GenericDefinition extends DataParserDefinitionTi
     ], GenericChecker>): DataParserTime<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 /**
- * Creates a data parser for TheTime values.
+ * Creates a classic parser for `TheTime` values.
  * 
- * **Supported call styles:**
- * - Classic: `DP.time(definition?)` -> returns a time parser
- * - Curried: not available
+ * Signature: `DP.time(definition?)` → `DataParserTime`
  * 
- * Validates that the input is a TheTime, optionally applies coerce, and runs the configured checkers.
+ * The parser accepts `TheTime`, `SerializedTheTime`, and safe numeric time values.
+ * With `coerce: true`, ISO-like time strings are also supported.
  * 
  * ```ts
  * const parser = DP.time();
@@ -41,13 +40,20 @@ export interface DataParserTime<GenericDefinition extends DataParserDefinitionTi
  * }
  * 
  * const withCheckers = DP.time({
- * 	checkers: [DP.checkerRefine((value) => value !== "time0+")],
+ * 	checkers: [DP.checkerRefine((value) => value.toNative() !== 0)],
  * });
+ * const checked = withCheckers.parse("time1000+");
+ * // checked: E.Error<DP.DataParserError> | E.Success<TheTime>
  * 
  * const coerceParser = DP.coerce.time();
  * const coerceResult = coerceParser.parse("10:20:00");
+ * // coerceResult: E.Error<DP.DataParserError> | E.Success<TheTime>
  * ```
  * 
+ * @remarks
+ * - Parsed output is always `TheTime`.
+ * - Use `DP.coerce.time()` when you want string coercion enabled by default.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
  * 
  * @namespace DP

package/dist/dataParser/parsers/time/index.mjs

@@ -1,13 +1,14 @@
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
-import { isSafeTimeValue } from '../../../date/isSafeTimeValue.mjs';
-import { createTheTime } from '../../../date/createTheTime.mjs';
 import { isoTimeRegex } from '../../../date/constants.mjs';
 import { createTime } from '../../../date/createTime.mjs';
 import { isLeft } from '../../../either/left/is.mjs';
 import { unwrap } from '../../../common/unwrap.mjs';
-import { isTime } from '../../../date/isTime.mjs';
+import { TheTime } from '../../../date/theTime.mjs';
+import { isSerializedTheTime } from '../../../date/isSerializedTheTime.mjs';
+import { toTimeValue } from '../../../date/toTimeValue.mjs';
+import { isSafeTimeValue } from '../../../date/isSafeTimeValue.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const timeKind = createDataParserKind("time");
@@ -21,12 +22,6 @@ function time(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
-            if (typeof data === "number") {
-                if (!isSafeTimeValue(data)) {
-                    return SymbolDataParserErrorIssue;
-                }
-                return createTheTime(data);
-            }
             if (typeof data === "string" && isoTimeRegex.test(data)) {
                 const result = createTime({ value: data });
                 if (isLeft(result)) {
@@ -35,9 +30,18 @@ function time(definition) {
                 return unwrap(result);
             }
         }
-        if (typeof data === "string" && isTime(data)) {
+        if (data instanceof TheTime) {
             return data;
         }
+        else if (typeof data === "string" && isSerializedTheTime(data)) {
+            return TheTime.new(toTimeValue(data));
+        }
+        else if (typeof data === "number") {
+            if (!isSafeTimeValue(data)) {
+                return SymbolDataParserErrorIssue;
+            }
+            return TheTime.new(data);
+        }
         return SymbolDataParserErrorIssue;
     }, time.overrideHandler);
     return self;