@duplojs/utils 1.4.57 → 1.4.59

package/dist/date/operators/addTime.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var createTheDate = require('../createTheDate.cjs');
-var createTheTime = require('../createTheTime.cjs');
+var isSerializedTheTime = require('../isSerializedTheTime.cjs');
+var theDate = require('../theDate.cjs');
+var theTime = require('../theTime.cjs');
 var toTimestamp = require('../toTimestamp.cjs');
 var toTimeValue = require('../toTimeValue.cjs');
 
@@ -11,11 +12,17 @@ function addTime(...args) {
         return (input) => addTime(input, time);
     }
     const [input, time] = args;
-    const timeTimestamp = toTimeValue.toTimeValue(time);
-    if (input.startsWith("date")) {
-        return createTheDate.createTheDate(toTimestamp.toTimestamp(input) + timeTimestamp);
+    const timeValue = toTimeValue.toTimeValue(time);
+    if (input instanceof theDate.TheDate) {
+        const timestamp = toTimestamp.toTimestamp(input);
+        return theDate.TheDate.new(timestamp + timeValue);
     }
-    return createTheTime.createTheTime(toTimeValue.toTimeValue(input) + timeTimestamp);
+    if (input instanceof theTime.TheTime || isSerializedTheTime.isSerializedTheTime(input)) {
+        const inputTimeValue = toTimeValue.toTimeValue(input);
+        return theTime.TheTime.new(inputTimeValue + timeValue);
+    }
+    const timestamp = toTimestamp.toTimestamp(input);
+    return theDate.TheDate.new(timestamp + timeValue);
 }
 
 exports.addTime = addTime;

package/dist/date/operators/addTime.d.ts

@@ -1,28 +1,30 @@
-import type { TheDate, TheTime } from "../types";
+import { TheDate } from "../theDate";
+import { TheTime } from "../theTime";
+import type { SerializedTheDate, SerializedTheTime } from "../types";
 /**
- * Adds a TheTime to a TheDate or TheTime.
+ * Adds a normalized duration (`TheTime` or `SerializedTheTime`) to a date.
  * 
  * **Supported call styles:**
- * - Classic: `addTime(input, time)` → returns a value
- * - Curried: `addTime(time)` → returns a function waiting for the input
+ * - Classic: `addTime(input, time)` → `TheDate | TheTime`
+ * - Curried: `addTime(time)` → `(input) => TheDate | TheTime`
  * 
- * The input value is not mutated.
+ * If `input` is `TheDate | SerializedTheDate`, the result is `TheDate`.
+ * The operator also supports `TheTime | SerializedTheTime` as input and returns `TheTime`.
  * 
  * ```ts
- * const date = D.createTheDate(0);
- * const time = D.createTheTime(3_600_000);
+ * const date = D.create("2024-06-20");
+ * const time = D.createTime(1, "hour");
  * 
  * const result = D.addTime(date, time);
- * // result: "date3600000+"
+ * // result: TheDate
  * 
- * const result2 = D.addTime("time3000+", "time2000+");
- * // result2: "time5000+"
+ * const result2 = D.addTime(time, D.createTime(30, "minute"));
+ * // result2: TheTime
  * 
- * const result3 = pipe(
+ * pipe(
  * 	date,
- * 	D.addTime("time1000+"),
- * );
- * // result3: "date3601000+"
+ * 	D.addTime(D.createTime(15, "minute")),
+ * ); // TheDate
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/addTime
@@ -30,7 +32,7 @@ import type { TheDate, TheTime } from "../types";
  * @namespace D
  * 
  */
-export declare function addTime<GenericInput extends TheDate>(time: TheTime): (input: GenericInput) => TheDate;
-export declare function addTime<GenericInput extends TheTime>(time: TheTime): (input: GenericInput) => TheTime;
-export declare function addTime<GenericInput extends TheDate>(input: GenericInput, time: TheTime): TheDate;
-export declare function addTime<GenericInput extends TheTime>(input: GenericInput, time: TheTime): TheTime;
+export declare function addTime<GenericInput extends TheDate | SerializedTheDate>(time: TheTime | SerializedTheTime): (input: GenericInput) => TheDate;
+export declare function addTime<GenericInput extends TheTime | SerializedTheTime>(time: TheTime | SerializedTheTime): (input: GenericInput) => TheTime;
+export declare function addTime<GenericInput extends TheDate | SerializedTheDate>(input: GenericInput, time: TheTime | SerializedTheTime): TheDate;
+export declare function addTime<GenericInput extends TheTime | SerializedTheTime>(input: GenericInput, time: TheTime | SerializedTheTime): TheTime;

package/dist/date/operators/addTime.mjs

@@ -1,5 +1,6 @@
-import { createTheDate } from '../createTheDate.mjs';
-import { createTheTime } from '../createTheTime.mjs';
+import { isSerializedTheTime } from '../isSerializedTheTime.mjs';
+import { TheDate } from '../theDate.mjs';
+import { TheTime } from '../theTime.mjs';
 import { toTimestamp } from '../toTimestamp.mjs';
 import { toTimeValue } from '../toTimeValue.mjs';
 
@@ -9,11 +10,17 @@ function addTime(...args) {
         return (input) => addTime(input, time);
     }
     const [input, time] = args;
-    const timeTimestamp = toTimeValue(time);
-    if (input.startsWith("date")) {
-        return createTheDate(toTimestamp(input) + timeTimestamp);
+    const timeValue = toTimeValue(time);
+    if (input instanceof TheDate) {
+        const timestamp = toTimestamp(input);
+        return TheDate.new(timestamp + timeValue);
     }
-    return createTheTime(toTimeValue(input) + timeTimestamp);
+    if (input instanceof TheTime || isSerializedTheTime(input)) {
+        const inputTimeValue = toTimeValue(input);
+        return TheTime.new(inputTimeValue + timeValue);
+    }
+    const timestamp = toTimestamp(input);
+    return TheDate.new(timestamp + timeValue);
 }
 
 export { addTime };

package/dist/date/operators/addWeeks.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var constants = require('../constants.cjs');
-var createTheDate = require('../createTheDate.cjs');
-var toNative = require('../toNative.cjs');
+var theDate = require('../theDate.cjs');
+var toTimestamp = require('../toTimestamp.cjs');
 
 function addWeeks(...args) {
     if (args.length === 1) {
@@ -10,9 +10,10 @@ function addWeeks(...args) {
         return (input) => addWeeks(input, week);
     }
     const [input, week] = args;
-    const date = toNative.toNative(input);
-    date.setTime(date.getTime() + (week * constants.millisecondInOneWeek));
-    return createTheDate.createTheDate(date.getTime());
+    const timestamp = input instanceof theDate.TheDate
+        ? input.getTime()
+        : toTimestamp.toTimestamp(input);
+    return theDate.TheDate.new(timestamp + (week * constants.millisecondInOneWeek));
 }
 
 exports.addWeeks = addWeeks;

package/dist/date/operators/addWeeks.d.ts

@@ -1,23 +1,26 @@
-import type { TheDate } from "../types";
+import { TheDate } from "../theDate";
+import type { SerializedTheDate } from "../types";
 /**
- * Adds weeks to a date.
+ * Adds a number of weeks to a date.
  * 
  * **Supported call styles:**
- * - Classic: `addWeeks(input, week)` → returns a value
- * - Curried: `addWeeks(week)` → returns a function waiting for the input
+ * - Classic: `addWeeks(input, week)` → `TheDate`
+ * - Curried: `addWeeks(week)` → `(input) => TheDate`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const input = D.create("2024-06-03");
  * const result = D.addWeeks(input, 2);
- * // result: "date1718841600000+"
+ * // result: TheDate
+ * 
+ * const serialized = D.serialize(result);
+ * // serialized: SerializedTheDate
  * 
  * pipe(
- * 	input,
+ * 	serialized,
  * 	D.addWeeks(2),
- * ); // result: "date1718841600000+"
- * 
+ * ); // TheDate
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/addWeeks
@@ -25,5 +28,5 @@ import type { TheDate } from "../types";
  * @namespace D
  * 
  */
-export declare function addWeeks<GenericInput extends TheDate, GenericWeek extends number>(week: GenericWeek): (input: GenericInput) => TheDate;
-export declare function addWeeks<GenericInput extends TheDate, GenericWeek extends number>(input: GenericInput, week: GenericWeek): TheDate;
+export declare function addWeeks<GenericInput extends TheDate | SerializedTheDate, GenericWeek extends number>(week: GenericWeek): (input: GenericInput) => TheDate;
+export declare function addWeeks<GenericInput extends TheDate | SerializedTheDate, GenericWeek extends number>(input: GenericInput, week: GenericWeek): TheDate;

package/dist/date/operators/addWeeks.mjs

@@ -1,6 +1,6 @@
 import { millisecondInOneWeek } from '../constants.mjs';
-import { createTheDate } from '../createTheDate.mjs';
-import { toNative } from '../toNative.mjs';
+import { TheDate } from '../theDate.mjs';
+import { toTimestamp } from '../toTimestamp.mjs';
 
 function addWeeks(...args) {
     if (args.length === 1) {
@@ -8,9 +8,10 @@ function addWeeks(...args) {
         return (input) => addWeeks(input, week);
     }
     const [input, week] = args;
-    const date = toNative(input);
-    date.setTime(date.getTime() + (week * millisecondInOneWeek));
-    return createTheDate(date.getTime());
+    const timestamp = input instanceof TheDate
+        ? input.getTime()
+        : toTimestamp(input);
+    return TheDate.new(timestamp + (week * millisecondInOneWeek));
 }
 
 export { addWeeks };

package/dist/date/operators/addYears.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var createTheDate = require('../createTheDate.cjs');
+var theDate = require('../theDate.cjs');
 var toNative = require('../toNative.cjs');
 
 function addYears(...args) {
@@ -11,7 +11,7 @@ function addYears(...args) {
     const [input, year] = args;
     const date = toNative.toNative(input);
     date.setUTCFullYear(date.getUTCFullYear() + year);
-    return createTheDate.createTheDate(date.getTime());
+    return theDate.TheDate.new(date.getTime());
 }
 
 exports.addYears = addYears;

package/dist/date/operators/addYears.d.ts

@@ -1,33 +1,33 @@
-import type { TheDate } from "../types";
+import { TheDate } from "../theDate";
+import type { SerializedTheDate } from "../types";
 /**
- * Adds years to a date.
+ * Adds a number of calendar years to a date.
  * 
  * **Supported call styles:**
- * - Classic: `addYears(input, year)` → returns a value
- * - Curried: `addYears(year)` → returns a function waiting for the input
+ * - Classic: `addYears(input, year)` → `TheDate`
+ * - Curried: `addYears(year)` → `(input) => TheDate`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const input = D.create("2020-02-29");
  * const result = D.addYears(input, 4);
- * // result: "date1766707200000+" (29 february 2024)
- * 
- * const addOneYear = D.addYears(1);
- * const result2 = addOneYear(input);
- * // result2: "date1646006400000+" (28 february 2023)
+ * // result: TheDate
  * 
  * pipe(
  * 	input,
  * 	D.addYears(4),
- * ); // result: "date1766707200000+" (29 february 2024)
+ * ); // TheDate
  * 
  * ```
  * 
+ * @remarks
+ * - Uses UTC year arithmetic (`Date#setUTCFullYear` behavior).
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/addYears
  * 
  * @namespace D
  * 
  */
-export declare function addYears<GenericInput extends TheDate, GenericYear extends number>(year: GenericYear): (input: GenericInput) => TheDate;
-export declare function addYears<GenericInput extends TheDate, GenericYear extends number>(input: GenericInput, year: GenericYear): TheDate;
+export declare function addYears<GenericInput extends TheDate | SerializedTheDate, GenericYear extends number>(year: GenericYear): (input: GenericInput) => TheDate;
+export declare function addYears<GenericInput extends TheDate | SerializedTheDate, GenericYear extends number>(input: GenericInput, year: GenericYear): TheDate;

package/dist/date/operators/addYears.mjs

@@ -1,4 +1,4 @@
-import { createTheDate } from '../createTheDate.mjs';
+import { TheDate } from '../theDate.mjs';
 import { toNative } from '../toNative.mjs';
 
 function addYears(...args) {
@@ -9,7 +9,7 @@ function addYears(...args) {
     const [input, year] = args;
     const date = toNative(input);
     date.setUTCFullYear(date.getUTCFullYear() + year);
-    return createTheDate(date.getTime());
+    return TheDate.new(date.getTime());
 }
 
 export { addYears };

package/dist/date/operators/between.d.ts

@@ -1,17 +1,18 @@
-import type { TheDate } from "../types";
+import { type TheDate } from "../theDate";
+import { type SerializedTheDate } from "../types";
 /**
- * Checks whether a date is between two dates (inclusive).
+ * Checks whether a date is inside an inclusive range.
  * 
  * **Supported call styles:**
- * - Classic: `between(input, greater, less)` → returns a value
- * - Curried: `between(greater, less)` → returns a function waiting for the input
+ * - Classic: `between(input, greater, less)` → `boolean`
+ * - Curried: `between(greater, less)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const start = D.create("2024-06-01");
  * const end = D.create("2024-06-30");
- * const input = D.create("2024-06-15");
+ * const input = D.create("2024-06-30");
  * 
  * const result = D.between(input, start, end);
  * // result: true
@@ -19,17 +20,16 @@ import type { TheDate } from "../types";
  * pipe(
  * 	input,
  * 	D.between(start, end),
- * ); // result: true
- * 
+ * ); // true
  * ```
  * 
  * @remarks
- * - Bounds are inclusive.
+ * - Inclusive bounds: `input >= greater && input <= less`.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/between
  * 
  * @namespace D
  * 
  */
-export declare function between<GenericValue extends TheDate>(greater: TheDate, less: TheDate): (input: GenericValue) => boolean;
-export declare function between<GenericValue extends TheDate>(input: GenericValue, greater: TheDate, less: TheDate): boolean;
+export declare function between<GenericValue extends TheDate | SerializedTheDate>(greater: TheDate | SerializedTheDate, less: TheDate | SerializedTheDate): (input: GenericValue) => boolean;
+export declare function between<GenericValue extends TheDate | SerializedTheDate>(input: GenericValue, greater: TheDate | SerializedTheDate, less: TheDate | SerializedTheDate): boolean;

package/dist/date/operators/betweenThan.d.ts

@@ -1,12 +1,13 @@
-import type { TheDate } from "../types";
+import type { TheDate } from "../theDate";
+import type { SerializedTheDate } from "../types";
 /**
- * Checks whether a date is between two dates (exclusive).
+ * Checks whether a date is inside an exclusive range.
  * 
  * **Supported call styles:**
- * - Classic: `betweenThan(input, greater, less)` → returns a value
- * - Curried: `betweenThan(greater, less)` → returns a function waiting for the input
+ * - Classic: `betweenThan(input, greater, less)` → `boolean`
+ * - Curried: `betweenThan(greater, less)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const start = D.create("2024-06-01");
@@ -14,22 +15,21 @@ import type { TheDate } from "../types";
  * const input = D.create("2024-06-30");
  * 
  * const result = D.betweenThan(input, start, end);
- * // result: true
+ * // result: false
  * 
  * pipe(
  * 	input,
  * 	D.betweenThan(start, end),
- * ); // result: true
- * 
+ * ); // false
  * ```
  * 
  * @remarks
- * - Bounds are exclusive.
+ * - Exclusive bounds: `input > greater && input < less`.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/betweenThan
  * 
  * @namespace D
  * 
  */
-export declare function betweenThan<GenericValue extends TheDate>(greater: TheDate, less: TheDate): (input: GenericValue) => boolean;
-export declare function betweenThan<GenericValue extends TheDate>(input: GenericValue, greater: TheDate, less: TheDate): boolean;
+export declare function betweenThan<GenericValue extends TheDate | SerializedTheDate>(greater: TheDate | SerializedTheDate, less: TheDate | SerializedTheDate): (input: GenericValue) => boolean;
+export declare function betweenThan<GenericValue extends TheDate | SerializedTheDate>(input: GenericValue, greater: TheDate | SerializedTheDate, less: TheDate | SerializedTheDate): boolean;

package/dist/date/operators/betweenThanTime.d.ts

@@ -1,39 +1,35 @@
-import type { TheTime } from "../types";
+import type { TheTime } from "../theTime";
+import type { SerializedTheTime } from "../types";
 /**
- * Checks whether a time is between two bounds (exclusive).
+ * Checks whether a duration is inside an exclusive range.
  * 
  * **Supported call styles:**
- * - Classic: `betweenThanTime(input, greater, less)` → returns a value
- * - Curried: `betweenThanTime(greater, less)` → returns a function waiting for the input
+ * - Classic: `betweenThanTime(input, greater, less)` → `boolean`
+ * - Curried: `betweenThanTime(greater, less)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheTime` or `SerializedTheTime`.
  * 
  * ```ts
- * const input = "time1500+";
- * const greater = "time1000+";
- * const less = "time2000+";
+ * const input = D.createTime(2, "hour");
+ * const greater = D.createTime(1, "hour");
+ * const less = D.createTime(2, "hour");
  * 
  * const result = D.betweenThanTime(input, greater, less);
- * // result: true
+ * // result: false
  * 
- * if (D.betweenThanTime(input, greater, less)) {
- * 	// input is strictly within bounds
- * }
- * 
- * const result2 = pipe(
+ * pipe(
  * 	input,
- * 	when(
- * 		D.betweenThanTime(greater, less),
- * 		() => "ok",
- * 	),
- * );
- * // result2: "ok"
+ * 	D.betweenThanTime(greater, less),
+ * ); // false
  * ```
  * 
+ * @remarks
+ * - Exclusive bounds: `input > greater && input < less`.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/betweenThanTime
  * 
  * @namespace D
  * 
  */
-export declare function betweenThanTime<GenericValue extends TheTime>(greater: TheTime, less: TheTime): (input: GenericValue) => boolean;
-export declare function betweenThanTime<GenericValue extends TheTime>(input: GenericValue, greater: TheTime, less: TheTime): boolean;
+export declare function betweenThanTime<GenericValue extends TheTime | SerializedTheTime>(greater: TheTime | SerializedTheTime, less: TheTime | SerializedTheTime): (input: GenericValue) => boolean;
+export declare function betweenThanTime<GenericValue extends TheTime | SerializedTheTime>(input: GenericValue, greater: TheTime | SerializedTheTime, less: TheTime | SerializedTheTime): boolean;

package/dist/date/operators/betweenTime.d.ts

@@ -1,39 +1,35 @@
-import type { TheTime } from "../types";
+import type { TheTime } from "../theTime";
+import type { SerializedTheTime } from "../types";
 /**
- * Checks whether a time is between two bounds (inclusive).
+ * Checks whether a duration is inside an inclusive range.
  * 
  * **Supported call styles:**
- * - Classic: `betweenTime(input, greater, less)` → returns a value
- * - Curried: `betweenTime(greater, less)` → returns a function waiting for the input
+ * - Classic: `betweenTime(input, greater, less)` → `boolean`
+ * - Curried: `betweenTime(greater, less)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheTime` or `SerializedTheTime`.
  * 
  * ```ts
- * const input = "time1500+";
- * const greater = "time1000+";
- * const less = "time2000+";
+ * const input = D.createTime(90, "minute");
+ * const greater = D.createTime(1, "hour");
+ * const less = D.createTime(2, "hour");
  * 
  * const result = D.betweenTime(input, greater, less);
  * // result: true
  * 
- * if (D.betweenTime(input, greater, less)) {
- * 	// input is within bounds
- * }
- * 
- * const result2 = pipe(
+ * pipe(
  * 	input,
- * 	when(
- * 		D.betweenTime(greater, less),
- * 		() => "ok",
- * 	),
- * );
- * // result2: "ok"
+ * 	D.betweenTime(greater, less),
+ * ); // true
  * ```
  * 
+ * @remarks
+ * - Inclusive bounds: `input >= greater && input <= less`.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/betweenTime
  * 
  * @namespace D
  * 
  */
-export declare function betweenTime<GenericValue extends TheTime>(greater: TheTime, less: TheTime): (input: GenericValue) => boolean;
-export declare function betweenTime<GenericValue extends TheTime>(input: GenericValue, greater: TheTime, less: TheTime): boolean;
+export declare function betweenTime<GenericValue extends TheTime | SerializedTheTime>(greater: TheTime | SerializedTheTime, less: TheTime | SerializedTheTime): (input: GenericValue) => boolean;
+export declare function betweenTime<GenericValue extends TheTime | SerializedTheTime>(input: GenericValue, greater: TheTime | SerializedTheTime, less: TheTime | SerializedTheTime): boolean;

package/dist/date/operators/greater.d.ts

@@ -1,12 +1,13 @@
-import type { TheDate } from "../types";
+import type { TheDate } from "../theDate";
+import type { SerializedTheDate } from "../types";
 /**
- * Checks whether a date is greater than or equal to another.
+ * Checks whether a date is greater than or equal to a threshold.
  * 
  * **Supported call styles:**
- * - Classic: `greater(input, threshold)` → returns a value
- * - Curried: `greater(threshold)` → returns a function waiting for the input
+ * - Classic: `greater(input, threshold)` → `boolean`
+ * - Curried: `greater(threshold)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const threshold = D.create("2024-06-01");
@@ -18,14 +19,16 @@ import type { TheDate } from "../types";
  * pipe(
  * 	input,
  * 	D.greater(threshold),
- * ); // result: true
- * 
+ * ); // true
  * ```
  * 
+ * @remarks
+ * - Inclusive comparison: `input >= threshold`.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/greater
  * 
  * @namespace D
  * 
  */
-export declare function greater<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
-export declare function greater<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;
+export declare function greater<GenericValue extends TheDate | SerializedTheDate>(threshold: TheDate | SerializedTheDate): (input: GenericValue) => boolean;
+export declare function greater<GenericValue extends TheDate | SerializedTheDate>(input: GenericValue, threshold: TheDate | SerializedTheDate): boolean;

package/dist/date/operators/greaterThan.d.ts

@@ -1,31 +1,34 @@
-import type { TheDate } from "../types";
+import type { TheDate } from "../theDate";
+import type { SerializedTheDate } from "../types";
 /**
- * Checks whether a date is strictly greater than another.
+ * Checks whether a date is strictly greater than a threshold.
  * 
  * **Supported call styles:**
- * - Classic: `greaterThan(input, threshold)` → returns a value
- * - Curried: `greaterThan(threshold)` → returns a function waiting for the input
+ * - Classic: `greaterThan(input, threshold)` → `boolean`
+ * - Curried: `greaterThan(threshold)` → `(input) => boolean`
  * 
- * The input value is not mutated.
+ * All parameters accept `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
  * const threshold = D.create("2024-06-20");
  * const input = D.create("2024-06-20");
  * 
- * const predicate = D.greaterThan(input, threshold);
- * // result: true
+ * const result = D.greaterThan(input, threshold);
+ * // result: false
  * 
  * pipe(
  * 	input,
  * 	D.greaterThan(threshold),
- * ); // result: true
- * 
+ * ); // false
  * ```
  * 
+ * @remarks
+ * - Strict comparison: `input > threshold`.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/greaterThan
  * 
  * @namespace D
  * 
  */
-export declare function greaterThan<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
-export declare function greaterThan<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;
+export declare function greaterThan<GenericValue extends TheDate | SerializedTheDate>(threshold: TheDate | SerializedTheDate): (input: GenericValue) => boolean;
+export declare function greaterThan<GenericValue extends TheDate | SerializedTheDate>(input: GenericValue, threshold: TheDate | SerializedTheDate): boolean;