@duplojs/utils 1.4.32 → 1.4.34

package/dist/clean/primitive/operations/date/dateMin.mjs

@@ -2,6 +2,9 @@ import { min } from '../../../../date/min.mjs';
 import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/dateMin/index.md}
+ */
 function dateMin(input) {
     return wrapValue(min(input.map(unwrap)));
 }

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

@@ -1,4 +1,39 @@
 import { type Date, type Time } from "../../base";
 import { type TheTime } from "../../../../date";
+/**
+ * Subtracts a time duration from a Date and returns a new wrapped Date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `dateSubtractTime(date, time)` -> returns a Date
+ * - Curried: `dateSubtractTime(time)` -> returns a function waiting for the date
+ * 
+ * Use it to move dates backward while keeping values wrapped.
+ * 
+ * ```ts
+ * const date = C.Date.createOrThrow(D.create("2024-01-02"));
+ * const halfMinute = C.Time.createOrThrow(D.createTheTime(30_000));
+ * 
+ * const earlier = C.dateSubtractTime(date, halfMinute);
+ * // earlier: C.Date
+ * 
+ * const curried = pipe(
+ * 	date,
+ * 	C.dateSubtractTime(D.createTheTime(1_000)),
+ * );
+ * // curried: C.Date
+ * 
+ * const mixed = C.dateSubtractTime(
+ * 	C.Date.createOrThrow(D.create("2024-01-01")),
+ * 	D.createTheTime(500),
+ * );
+ * // mixed: C.Date
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/dateSubtractTime
+ * 
+ * @namespace C
+ * 
+ */
 export declare function dateSubtractTime(time: Time | TheTime): (primitive: Date) => Date;
 export declare function dateSubtractTime(primitive: Date, time: Time | TheTime): Date;

package/dist/clean/primitive/operations/equal.d.ts

@@ -1,4 +1,38 @@
 import { type ToLargeEnsemble, type Unwrap } from "../../../common";
 import { type Primitive, type Primitives, type Date, type Time } from "../base";
+/**
+ * Compares two wrapped primitives (or a primitive and a raw value) with a type guard.
+ * 
+ * **Supported call styles:**
+ * - Classic: `equal(input, value)` -> returns a boolean
+ * - Curried: `equal(value)` -> returns a function waiting for the input
+ * - Classic predicate: `equal(input, value)` -> narrows the primitive type
+ * - Curried predicate: `equal(value)` -> narrows the primitive type
+ * 
+ * Use it to match business values while keeping type safety during checks and filtering.
+ * 
+ * ```ts
+ * const status = C.String.createOrThrow("paid");
+ * 
+ * if (C.equal(status, "paid")) {
+ * 	// status is C.Primitive<"paid">
+ * }
+ * 
+ * const paid = C.String.createOrThrow("paid");
+ * 
+ * if (C.equal(status, paid)) {
+ * 	// status is C.Primitive<"paid">
+ * }
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Predicate overloads narrow the output type when the comparison succeeds.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/equal
+ * 
+ * @namespace C
+ * 
+ */
 export declare function equal<GenericInput extends Primitives, GenericValue extends (GenericInput extends Date ? (Date | Unwrap<Date>) : GenericInput extends Time ? (Time | Unwrap<Time>) : (Primitive<ToLargeEnsemble<Unwrap<GenericInput>>> | ToLargeEnsemble<Unwrap<GenericInput>>))>(value: GenericValue): (input: GenericInput) => input is GenericInput & Primitive<Unwrap<GenericValue>>;
 export declare function equal<GenericInput extends Primitives, GenericValue extends (GenericInput extends Date ? (Date | Unwrap<Date>) : GenericInput extends Time ? (Time | Unwrap<Time>) : (Primitive<ToLargeEnsemble<Unwrap<GenericInput>>> | ToLargeEnsemble<Unwrap<GenericInput>>))>(input: GenericInput, value: GenericValue): input is GenericInput & Primitive<Unwrap<GenericValue>>;

package/dist/clean/primitive/operations/number/add.d.ts

@@ -1,3 +1,37 @@
 import { type Number } from "../../base";
+/**
+ * Adds two Number values (wrapped or raw) and returns a wrapped Number.
+ * 
+ * **Supported call styles:**
+ * - Classic: `add(value, operand)` -> returns a Number
+ * - Curried: `add(operand)` -> returns a function waiting for the value
+ * 
+ * Use it to keep numeric operations in the Clean domain while preserving types.
+ * 
+ * ```ts
+ * const value = C.Number.createOrThrow(10);
+ * 
+ * const summed = C.add(value, 5);
+ * // summed: C.Number
+ * 
+ * const curried = pipe(
+ * 	value,
+ * 	C.add(2),
+ * );
+ * // curried: C.Number
+ * 
+ * const combined = C.add(
+ * 	C.Number.createOrThrow(4),
+ * 	C.Number.createOrThrow(6),
+ * );
+ * // combined: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/add
+ * 
+ * @namespace C
+ * 
+ */
 export declare function add(operand: Number | number): (value: Number) => Number;
 export declare function add(value: Number, operand: Number | number): Number;

package/dist/clean/primitive/operations/number/divide.d.ts

@@ -1,3 +1,37 @@
 import { type Number } from "../../base";
+/**
+ * Divides a Number by a divisor and returns a wrapped Number.
+ * 
+ * **Supported call styles:**
+ * - Classic: `divide(value, divisor)` -> returns a Number
+ * - Curried: `divide(divisor)` -> returns a function waiting for the value
+ * 
+ * Use it for domain arithmetic while keeping numbers wrapped.
+ * 
+ * ```ts
+ * const value = C.Number.createOrThrow(12);
+ * 
+ * const ratio = C.divide(value, 3);
+ * // ratio: C.Number
+ * 
+ * const curried = pipe(
+ * 	value,
+ * 	C.divide(2),
+ * );
+ * // curried: C.Number
+ * 
+ * const combined = C.divide(
+ * 	C.Number.createOrThrow(20),
+ * 	C.Number.createOrThrow(5),
+ * );
+ * // combined: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/divide
+ * 
+ * @namespace C
+ * 
+ */
 export declare function divide(divisor: Number | number): (value: Number) => Number;
 export declare function divide(value: Number, divisor: Number | number): Number;

package/dist/clean/primitive/operations/number/greaterThan.d.ts

@@ -1,3 +1,28 @@
 import { type Number } from "../../base";
+/**
+ * Checks whether a Number is strictly greater than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greaterThan(value, threshold)` -> returns a boolean
+ * - Curried: `greaterThan(threshold)` -> returns a function waiting for the value
+ * 
+ * Use it to compare wrapped numbers while keeping values in the Clean domain.
+ * 
+ * ```ts
+ * const age = C.Number.createOrThrow(20);
+ * 
+ * C.greaterThan(age, 18); // true
+ * 
+ * if (C.greaterThan(age, 18)) {
+ * 	// age is greater than 18
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/greaterThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function greaterThan(threshold: Number | number): (value: Number) => boolean;
 export declare function greaterThan(primitive: Number, threshold: Number | number): boolean;

package/dist/clean/primitive/operations/number/lessThan.d.ts

@@ -1,3 +1,28 @@
 import { type Number } from "../../base";
+/**
+ * Checks whether a Number is strictly less than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lessThan(value, threshold)` -> returns a boolean
+ * - Curried: `lessThan(threshold)` -> returns a function waiting for the value
+ * 
+ * Use it to compare wrapped numbers while keeping values in the Clean domain.
+ * 
+ * ```ts
+ * const speed = C.Number.createOrThrow(30);
+ * 
+ * C.lessThan(speed, 50); // true
+ * 
+ * if (C.lessThan(speed, 40)) {
+ * 	// speed is less than 40
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/lessThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function lessThan(threshold: Number | number): (value: Number) => boolean;
 export declare function lessThan(primitive: Number, threshold: Number | number): boolean;

package/dist/clean/primitive/operations/number/max.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../../../../common/wrapValue.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/max/index.md}
+ */
 function max(input) {
     return wrapValue.wrapValue(Math.max(...input.map(unwrap.unwrap)));
 }

package/dist/clean/primitive/operations/number/max.d.ts

@@ -1,3 +1,36 @@
 import { type AnyTuple } from "../../../../common";
 import { type Number } from "../../base";
+/**
+ * Returns the largest value from a tuple of Numbers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `max(input)` -> returns a Number
+ * 
+ * The input can mix wrapped Numbers and raw numbers.
+ * 
+ * ```ts
+ * const largest = C.max([
+ * 	C.Number.createOrThrow(3),
+ * 	10,
+ * 	1,
+ * ]);
+ * // largest: C.Number
+ * 
+ * const fromRaw = C.max([2, 8, 4]);
+ * // fromRaw: C.Number
+ * 
+ * const mixed = C.max([
+ * 	C.Number.createOrThrow(5),
+ * 	C.Number.createOrThrow(2),
+ * 	9,
+ * ]);
+ * // mixed: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/max
+ * 
+ * @namespace C
+ * 
+ */
 export declare function max(input: AnyTuple<Number | number>): Number;

package/dist/clean/primitive/operations/number/max.mjs

@@ -1,6 +1,9 @@
 import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/max/index.md}
+ */
 function max(input) {
     return wrapValue(Math.max(...input.map(unwrap)));
 }

package/dist/clean/primitive/operations/number/min.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../../../../common/wrapValue.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/min/index.md}
+ */
 function min(input) {
     return wrapValue.wrapValue(Math.min(...input.map(unwrap.unwrap)));
 }

package/dist/clean/primitive/operations/number/min.d.ts

@@ -1,3 +1,36 @@
 import { type AnyTuple } from "../../../../common";
 import { type Number } from "../../base";
+/**
+ * Returns the smallest value from a tuple of Numbers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `min(input)` -> returns a Number
+ * 
+ * The input can mix wrapped Numbers and raw numbers.
+ * 
+ * ```ts
+ * const smallest = C.min([
+ * 	C.Number.createOrThrow(3),
+ * 	10,
+ * 	1,
+ * ]);
+ * // smallest: C.Number
+ * 
+ * const fromRaw = C.min([2, 8, 4]);
+ * // fromRaw: C.Number
+ * 
+ * const mixed = C.min([
+ * 	C.Number.createOrThrow(5),
+ * 	C.Number.createOrThrow(2),
+ * 	9,
+ * ]);
+ * // mixed: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/min
+ * 
+ * @namespace C
+ * 
+ */
 export declare function min(input: AnyTuple<Number | number>): Number;

package/dist/clean/primitive/operations/number/min.mjs

@@ -1,6 +1,9 @@
 import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/min/index.md}
+ */
 function min(input) {
     return wrapValue(Math.min(...input.map(unwrap)));
 }

package/dist/clean/primitive/operations/number/multiply.d.ts

@@ -1,3 +1,37 @@
 import { type Number } from "../../base";
+/**
+ * Multiplies a Number by a factor and returns a wrapped Number.
+ * 
+ * **Supported call styles:**
+ * - Classic: `multiply(value, multiplier)` -> returns a Number
+ * - Curried: `multiply(multiplier)` -> returns a function waiting for the value
+ * 
+ * Use it for domain arithmetic while keeping numbers wrapped.
+ * 
+ * ```ts
+ * const value = C.Number.createOrThrow(4);
+ * 
+ * const scaled = C.multiply(value, 3);
+ * // scaled: C.Number
+ * 
+ * const curried = pipe(
+ * 	value,
+ * 	C.multiply(2),
+ * );
+ * // curried: C.Number
+ * 
+ * const combined = C.multiply(
+ * 	C.Number.createOrThrow(5),
+ * 	C.Number.createOrThrow(6),
+ * );
+ * // combined: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/multiply
+ * 
+ * @namespace C
+ * 
+ */
 export declare function multiply(multiplier: Number | number): (value: Number) => Number;
 export declare function multiply(value: Number, multiplier: Number | number): Number;

package/dist/clean/primitive/operations/number/subtract.d.ts

@@ -1,3 +1,37 @@
 import { type Number } from "../../base";
+/**
+ * Subtracts a value from a Number and returns a wrapped Number.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtract(value, subtrahend)` -> returns a Number
+ * - Curried: `subtract(subtrahend)` -> returns a function waiting for the value
+ * 
+ * Use it for domain arithmetic while keeping numbers wrapped.
+ * 
+ * ```ts
+ * const value = C.Number.createOrThrow(10);
+ * 
+ * const reduced = C.subtract(value, 3);
+ * // reduced: C.Number
+ * 
+ * const curried = pipe(
+ * 	value,
+ * 	C.subtract(2),
+ * );
+ * // curried: C.Number
+ * 
+ * const combined = C.subtract(
+ * 	C.Number.createOrThrow(8),
+ * 	C.Number.createOrThrow(5),
+ * );
+ * // combined: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/subtract
+ * 
+ * @namespace C
+ * 
+ */
 export declare function subtract(subtrahend: Number | number): (value: Number) => Number;
 export declare function subtract(value: Number, subtrahend: Number | number): Number;

package/dist/clean/primitive/operations/sort.d.ts

@@ -1,5 +1,43 @@
 import { type Date, type Number, type String, type Time } from "../base";
 import { type ToWrappedValue, type SortType } from "../../../common";
 import * as DDate from "../../../date";
+/**
+ * Sorts an array of primitives (String, Number, Date, Time) in ascending or descending order.
+ * 
+ * **Supported call styles:**
+ * - Classic: `sort(input, type)` -> returns a new array
+ * - Curried: `sort(type)` -> returns a function waiting for the input
+ * 
+ * The output array contains wrapped primitives.
+ * 
+ * ```ts
+ * const numbers = [
+ * 	C.Number.createOrThrow(3),
+ * 	1,
+ * 	2,
+ * ];
+ * 
+ * const asc = C.sort(numbers, "ASC");
+ * // asc: C.Number[]
+ * 
+ * const desc = pipe(
+ * 	numbers,
+ * 	C.sort("DSC"),
+ * );
+ * // desc: C.Number[]
+ * 
+ * const dates = C.sort([
+ * 	D.createTheDate(2),
+ * 	D.createTheDate(1),
+ * ], "ASC");
+ * // dates: C.Date[]
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/sort
+ * 
+ * @namespace C
+ * 
+ */
 export declare function sort<GenericInput extends (readonly (Date | DDate.TheDate)[] | readonly (Number | number)[] | readonly (String | string)[] | readonly (Time | DDate.TheTime)[])>(type: SortType): (input: GenericInput) => ToWrappedValue<GenericInput[number]>[];
 export declare function sort<GenericInput extends (readonly (Date | DDate.TheDate)[] | readonly (Number | number)[] | readonly (String | string)[] | readonly (Time | DDate.TheTime)[])>(input: GenericInput, type: SortType): ToWrappedValue<GenericInput[number]>[];

package/dist/clean/primitive/operations/string/concat.d.ts

@@ -1,3 +1,38 @@
 import { type String } from "../../base";
+/**
+ * Concatenates strings and returns a wrapped String.
+ * 
+ * **Supported call styles:**
+ * - Classic: `concat(input, ...texts)` -> returns a String
+ * - Curried: `concat(text)` -> returns a function waiting for the input
+ * 
+ * Use it to build string values while staying inside the Clean domain.
+ * 
+ * ```ts
+ * const name = C.String.createOrThrow("Duplo");
+ * 
+ * const full = C.concat(name, "JS");
+ * // full: C.String
+ * 
+ * const curried = pipe(
+ * 	name,
+ * 	C.concat(" Utils"),
+ * );
+ * // curried: C.String
+ * 
+ * const mixed = C.concat(
+ * 	C.String.createOrThrow("Hello"),
+ * 	" ",
+ * 	"World",
+ * );
+ * // mixed: C.String
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/concat
+ * 
+ * @namespace C
+ * 
+ */
 export declare function concat(text: String | string): (input: String) => String;
 export declare function concat(input: String, ...textsRest: (String | string)[]): String;

package/dist/clean/primitive/operations/string/length.cjs

@@ -3,6 +3,9 @@
 var wrapValue = require('../../../../common/wrapValue.cjs');
 var unwrap = require('../../../../common/unwrap.cjs');
 
+/**
+ * {@include clean/length/index.md}
+ */
 function length(primitive) {
     return wrapValue.wrapValue(unwrap.unwrap(primitive).length);
 }

package/dist/clean/primitive/operations/string/length.d.ts

@@ -1,2 +1,29 @@
 import { type Number, type String } from "../../base";
+/**
+ * Returns the length of a String as a wrapped Number.
+ * 
+ * **Supported call styles:**
+ * - Classic: `length(primitive)` -> returns a Number
+ * 
+ * Use it to keep string-length calculations in the Clean domain.
+ * 
+ * ```ts
+ * const name = C.String.createOrThrow("Duplo");
+ * 
+ * const size = C.length(name);
+ * // size: C.Number
+ * 
+ * const fromRaw = C.length(C.String.createOrThrow("Utils"));
+ * // fromRaw: C.Number
+ * 
+ * const empty = C.length(C.String.createOrThrow(""));
+ * // empty: C.Number
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/length
+ * 
+ * @namespace C
+ * 
+ */
 export declare function length(primitive: String): Number;

package/dist/clean/primitive/operations/string/length.mjs

@@ -1,6 +1,9 @@
 import { wrapValue } from '../../../../common/wrapValue.mjs';
 import { unwrap } from '../../../../common/unwrap.mjs';
 
+/**
+ * {@include clean/length/index.md}
+ */
 function length(primitive) {
     return wrapValue(unwrap(primitive).length);
 }

package/dist/clean/primitive/operations/string/lengthEqual.d.ts

@@ -1,3 +1,28 @@
 import { type Number, type String } from "../../base";
+/**
+ * Checks whether a String length equals a given value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lengthEqual(primitive, length)` -> returns a boolean
+ * - Curried: `lengthEqual(length)` -> returns a function waiting for the primitive
+ * 
+ * Use it to validate string sizes with wrapped Number values.
+ * 
+ * ```ts
+ * const token = C.String.createOrThrow("abcd");
+ * 
+ * C.lengthEqual(token, 4); // true
+ * 
+ * if (C.lengthEqual(token, 4)) {
+ * 	// token has length 4
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/lengthEqual
+ * 
+ * @namespace C
+ * 
+ */
 export declare function lengthEqual(length: Number | number): (primitive: String) => boolean;
 export declare function lengthEqual(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/string/lengthGreaterThan.d.ts

@@ -1,3 +1,28 @@
 import { type Number, type String } from "../../base";
+/**
+ * Checks whether a String length is greater than a given value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lengthGreaterThan(primitive, length)` -> returns a boolean
+ * - Curried: `lengthGreaterThan(length)` -> returns a function waiting for the primitive
+ * 
+ * Use it to validate minimum sizes with wrapped Number values.
+ * 
+ * ```ts
+ * const label = C.String.createOrThrow("DuploJS");
+ * 
+ * C.lengthGreaterThan(label, 3); // true
+ * 
+ * if (C.lengthGreaterThan(label, 5)) {
+ * 	// label has length greater than 5
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/lengthGreaterThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function lengthGreaterThan(length: Number | number): (primitive: String) => boolean;
 export declare function lengthGreaterThan(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/string/lengthLessThan.d.ts

@@ -1,3 +1,28 @@
 import { type Number, type String } from "../../base";
+/**
+ * Checks whether a String length is less than a given value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lengthLessThan(primitive, length)` -> returns a boolean
+ * - Curried: `lengthLessThan(length)` -> returns a function waiting for the primitive
+ * 
+ * Use it to validate maximum sizes with wrapped Number values.
+ * 
+ * ```ts
+ * const code = C.String.createOrThrow("AB");
+ * 
+ * C.lengthLessThan(code, 5); // true
+ * 
+ * if (C.lengthLessThan(code, 3)) {
+ * 	// code has length less than 3
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/lengthLessThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function lengthLessThan(length: Number | number): (primitive: String) => boolean;
 export declare function lengthLessThan(primitive: String, length: Number | number): boolean;

package/dist/clean/primitive/operations/time/timeGreaterThan.d.ts

@@ -1,4 +1,28 @@
 import { type Time } from "../../base";
 import { type TheTime } from "../../../../date";
+/**
+ * Checks whether a Time is greater than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `timeGreaterThan(time, threshold)` -> returns a boolean
+ * - Curried: `timeGreaterThan(threshold)` -> returns a function waiting for the time
+ * 
+ * Use it to compare wrapped durations or raw TheTime values.
+ * 
+ * ```ts
+ * const duration = C.Time.createOrThrow(D.createTheTime(3_600_000));
+ * const threshold = D.createTheTime(1_800_000);
+ * 
+ * if (C.timeGreaterThan(duration, threshold)) {
+ * 	// duration is greater than threshold
+ * }
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/primitives/operators/timeGreaterThan
+ * 
+ * @namespace C
+ * 
+ */
 export declare function timeGreaterThan(threshold: Time | TheTime): (primitive: Time) => boolean;
 export declare function timeGreaterThan(primitive: Time, threshold: Time | TheTime): boolean;