ts-data-forge 6.13.1 → 7.0.0

package/dist/number/branded-types/negative-int.mjs

@@ -0,0 +1,125 @@
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveInt } from './positive-int.mjs';
+
+const typeNameInMessage = 'a negative integer';
+const { MAX_VALUE, add, castType, clamp, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -1,
+    typeNameInMessage,
+});
+/**
+ * Returns the absolute value of a negative integer.
+ *
+ * The absolute value of a negative integer is always a positive integer
+ * (`>= 1`), so the result is typed as a {@link PositiveInt}.
+ *
+ * @param x - The negative integer.
+ * @returns `|x|` as a PositiveInt.
+ */
+const abs = (x) => PositiveInt.clamp(Math.abs(x));
+/**
+ * Checks if a number is a NegativeInt (a negative integer `<= -1`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeInt, `false` otherwise.
+ */
+const isNegativeInt = is;
+/**
+ * Casts a number to a NegativeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeInt type.
+ * @throws {TypeError} If the value is not a negative integer.
+ */
+const asNegativeInt = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for negative integers.
+ *
+ * NegativeInt represents integers that are strictly less than zero (`<= -1`).
+ * Operations that stay within the negative integers (such as `add`) clamp their
+ * results to the valid range, while operations whose result leaves the set
+ * (`mul`, `div`, `abs`) are typed to reflect the actual sign of the result.
+ */
+const NegativeInt = {
+    /**
+     * Type guard to check if a value is a NegativeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The maximum value for a negative integer.
+     *
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the absolute value of a negative integer.
+     *
+     * @param a The negative integer.
+     * @returns The absolute value as a PositiveInt.
+     */
+    abs,
+    /**
+     * Returns the smaller of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The minimum value as a NegativeInt.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The maximum value as a NegativeInt.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the negative integer range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[-∞, -1]` as a NegativeInt.
+     */
+    clamp,
+    /**
+     * Generates a random NegativeInt value within the valid range.
+     *
+     * @returns A random negative integer.
+     */
+    random,
+    /**
+     * Raises a negative integer to the power of another negative integer.
+     *
+     * @param a The base negative integer.
+     * @param b The exponent negative integer.
+     * @returns `a ** b` clamped to the negative integer range.
+     */
+    pow,
+    /**
+     * Adds two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns `a + b` as a NegativeInt.
+     */
+    add,
+    /**
+     * Subtracts one negative integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * integer range (maximum `-1`).
+     *
+     * @param a The minuend negative integer.
+     * @param b The subtrahend negative integer.
+     * @returns `a - b` clamped to the negative integer range.
+     */
+    sub,
+};
+
+export { NegativeInt, asNegativeInt, isNegativeInt };
+//# sourceMappingURL=negative-int.mjs.map

package/dist/number/branded-types/negative-int.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-int.mjs","sources":["../../../src/number/branded-types/negative-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,EAAE;IACb,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;AAQG;AACH,MAAM,GAAG,GAAG,CAAC,CAA4B,KACvC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEhC;;;;;AAKG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;AAMG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;AAOG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/negative-safe-int.d.mts

@@ -0,0 +1,132 @@
+import { type NegativeSafeInt as TtfImported_NegativeSafeInt, type WithSmallInt } from 'ts-type-forge';
+import { PositiveSafeInt } from './positive-safe-int.mjs';
+export type NegativeSafeInt = TtfImported_NegativeSafeInt;
+type ElementType = NegativeSafeInt;
+/**
+ * Checks if a number is a NegativeSafeInt (a negative safe integer in the range
+ * `[Number.MIN_SAFE_INTEGER, -1]`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeSafeInt, `false` otherwise.
+ */
+export declare const isNegativeSafeInt: (a: number) => a is TtfImported_NegativeSafeInt;
+/**
+ * Casts a number to a NegativeSafeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeSafeInt type.
+ * @throws {TypeError} If the value is not a negative safe integer.
+ */
+export declare const asNegativeSafeInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly ">=0": false;
+    readonly "!=0": true;
+    readonly "<=0": true;
+    readonly "< 2^15": true;
+    readonly "< 2^16": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+    readonly SafeInt: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for negative safe
+ * integers.
+ *
+ * NegativeSafeInt represents safe integers that are strictly less than zero
+ * (`[Number.MIN_SAFE_INTEGER, -1]`). Operations that stay within the negative
+ * safe integers clamp their results to the valid range, while operations whose
+ * result leaves the set (`mul`, `div`, `abs`) are typed to reflect the actual
+ * sign of the result.
+ */
+export declare const NegativeSafeInt: {
+    /**
+     * Type guard to check if a value is a NegativeSafeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative safe integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NegativeSafeInt;
+    /**
+     * The minimum value for a negative safe integer.
+     *
+     * @readonly
+     */
+    readonly MIN_VALUE: number;
+    /**
+     * The maximum value for a negative safe integer.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: -1;
+    /**
+     * Returns the absolute value of a negative safe integer.
+     *
+     * @param a The negative safe integer.
+     * @returns The absolute value as a PositiveSafeInt.
+     */
+    readonly abs: (x: WithSmallInt<ElementType>) => PositiveSafeInt;
+    /**
+     * Returns the smaller of two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns The minimum value as a NegativeSafeInt.
+     */
+    readonly min: (...values: readonly WithSmallInt<TtfImported_NegativeSafeInt>[]) => TtfImported_NegativeSafeInt;
+    /**
+     * Returns the larger of two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns The maximum value as a NegativeSafeInt.
+     */
+    readonly max: (...values: readonly WithSmallInt<TtfImported_NegativeSafeInt>[]) => TtfImported_NegativeSafeInt;
+    /**
+     * Clamps a number to the NegativeSafeInt range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[Number.MIN_SAFE_INTEGER, -1]` as a
+     *   NegativeSafeInt.
+     */
+    readonly clamp: (x: number) => TtfImported_NegativeSafeInt;
+    /**
+     * Generates a random NegativeSafeInt value within the valid range.
+     *
+     * @returns A random NegativeSafeInt between Number.MIN_SAFE_INTEGER and -1.
+     */
+    readonly random: (min?: WithSmallInt<TtfImported_NegativeSafeInt> | undefined, max?: WithSmallInt<TtfImported_NegativeSafeInt> | undefined) => TtfImported_NegativeSafeInt;
+    /**
+     * Raises a negative safe integer to the power of another negative safe
+     * integer.
+     *
+     * @param a The base negative safe integer.
+     * @param b The exponent negative safe integer.
+     * @returns `a ** b` clamped to the NegativeSafeInt range.
+     */
+    readonly pow: (x: WithSmallInt<TtfImported_NegativeSafeInt>, y: WithSmallInt<TtfImported_NegativeSafeInt>) => TtfImported_NegativeSafeInt;
+    /**
+     * Adds two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns `a + b` clamped to the NegativeSafeInt range.
+     */
+    readonly add: (x: WithSmallInt<TtfImported_NegativeSafeInt>, y: WithSmallInt<TtfImported_NegativeSafeInt>) => TtfImported_NegativeSafeInt;
+    /**
+     * Subtracts one negative safe integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the
+     * NegativeSafeInt range (maximum `-1`).
+     *
+     * @param a The minuend negative safe integer.
+     * @param b The subtrahend negative safe integer.
+     * @returns `a - b` clamped to the NegativeSafeInt range.
+     */
+    readonly sub: (x: WithSmallInt<TtfImported_NegativeSafeInt>, y: WithSmallInt<TtfImported_NegativeSafeInt>) => TtfImported_NegativeSafeInt;
+};
+export {};
+//# sourceMappingURL=negative-safe-int.d.mts.map

package/dist/number/branded-types/negative-safe-int.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,IAAI,2BAA2B,EACnD,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE1D,KAAK,WAAW,GAAG,eAAe,CAAC;AAwCnC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;sBA3DW,YAAY,CAAC,WAAW,CAAC,KAAG,eAAe;IA8DzD;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;CAEK,CAAC"}

package/dist/number/branded-types/negative-safe-int.mjs

@@ -0,0 +1,136 @@
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveSafeInt } from './positive-safe-int.mjs';
+
+const typeNameInMessage = 'a negative safe integer';
+const { MAX_VALUE, MIN_VALUE, add, castType, clamp, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    nonZero: true,
+    MIN_VALUE: Number.MIN_SAFE_INTEGER,
+    MAX_VALUE: -1,
+    typeNameInMessage,
+});
+/**
+ * Returns the absolute value of a negative safe integer.
+ *
+ * The absolute value of a negative safe integer is always a positive safe
+ * integer (`>= 1`), so the result is typed as a {@link PositiveSafeInt}.
+ *
+ * @param x - The negative safe integer.
+ * @returns `|x|` as a PositiveSafeInt.
+ */
+const abs = (x) => PositiveSafeInt.clamp(Math.abs(x));
+/**
+ * Checks if a number is a NegativeSafeInt (a negative safe integer in the range
+ * `[Number.MIN_SAFE_INTEGER, -1]`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeSafeInt, `false` otherwise.
+ */
+const isNegativeSafeInt = is;
+/**
+ * Casts a number to a NegativeSafeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeSafeInt type.
+ * @throws {TypeError} If the value is not a negative safe integer.
+ */
+const asNegativeSafeInt = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for negative safe
+ * integers.
+ *
+ * NegativeSafeInt represents safe integers that are strictly less than zero
+ * (`[Number.MIN_SAFE_INTEGER, -1]`). Operations that stay within the negative
+ * safe integers clamp their results to the valid range, while operations whose
+ * result leaves the set (`mul`, `div`, `abs`) are typed to reflect the actual
+ * sign of the result.
+ */
+const NegativeSafeInt = {
+    /**
+     * Type guard to check if a value is a NegativeSafeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative safe integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a negative safe integer.
+     *
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a negative safe integer.
+     *
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the absolute value of a negative safe integer.
+     *
+     * @param a The negative safe integer.
+     * @returns The absolute value as a PositiveSafeInt.
+     */
+    abs,
+    /**
+     * Returns the smaller of two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns The minimum value as a NegativeSafeInt.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns The maximum value as a NegativeSafeInt.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the NegativeSafeInt range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[Number.MIN_SAFE_INTEGER, -1]` as a
+     *   NegativeSafeInt.
+     */
+    clamp,
+    /**
+     * Generates a random NegativeSafeInt value within the valid range.
+     *
+     * @returns A random NegativeSafeInt between Number.MIN_SAFE_INTEGER and -1.
+     */
+    random,
+    /**
+     * Raises a negative safe integer to the power of another negative safe
+     * integer.
+     *
+     * @param a The base negative safe integer.
+     * @param b The exponent negative safe integer.
+     * @returns `a ** b` clamped to the NegativeSafeInt range.
+     */
+    pow,
+    /**
+     * Adds two negative safe integers.
+     *
+     * @param a The first negative safe integer.
+     * @param b The second negative safe integer.
+     * @returns `a + b` clamped to the NegativeSafeInt range.
+     */
+    add,
+    /**
+     * Subtracts one negative safe integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the
+     * NegativeSafeInt range (maximum `-1`).
+     *
+     * @param a The minuend negative safe integer.
+     * @param b The subtrahend negative safe integer.
+     * @returns `a - b` clamped to the NegativeSafeInt range.
+     */
+    sub,
+};
+
+export { NegativeSafeInt, asNegativeSafeInt, isNegativeSafeInt };
+//# sourceMappingURL=negative-safe-int.mjs.map

package/dist/number/branded-types/negative-safe-int.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-safe-int.mjs","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,MAAM,CAAC,gBAAgB;IAClC,SAAS,EAAE,EAAE;IACb,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;AAQG;AACH,MAAM,GAAG,GAAG,CAAC,CAA4B,KACvC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEpC;;;;;;AAMG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;AAMG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;AASG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/non-negative-finite-number.d.mts

@@ -145,12 +145,12 @@ export declare const NonNegativeFiniteNumber: {
     readonly div: (x: TtfImported_NonNegativeFiniteNumber, y: number & {
         readonly NaNValue: false;
         readonly Finite: true;
-        readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
+        readonly "!=0": true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
     }>) => TtfImported_NonNegativeFiniteNumber;

package/dist/number/branded-types/non-negative-int16.d.mts

@@ -134,12 +134,12 @@ export declare const NonNegativeInt16: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
+        readonly "!=0": true;
         readonly "< 2^15": true;
         readonly "< 2^16": true;
         readonly "< 2^31": true;

package/dist/number/branded-types/non-negative-int32.d.mts

@@ -133,12 +133,12 @@ export declare const NonNegativeInt32: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
+        readonly "!=0": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
         readonly SafeInt: true;

package/dist/number/branded-types/non-positive-finite-number.d.mts

@@ -0,0 +1,130 @@
+import { type NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;
+type ElementType = NonPositiveFiniteNumber;
+/**
+ * Checks if a number is a NonPositiveFiniteNumber (a finite number <= 0).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NonPositiveFiniteNumber, `false` otherwise.
+ */
+export declare const isNonPositiveFiniteNumber: (a: number) => a is TtfImported_NonPositiveFiniteNumber;
+/**
+ * Casts a number to a NonPositiveFiniteNumber type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NonPositiveFiniteNumber type.
+ * @throws {TypeError} If the value is not a non-positive finite number.
+ */
+export declare const asNonPositiveFiniteNumber: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly "<=0": true;
+    readonly "< 2^15": true;
+    readonly "< 2^16": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for non-positive finite
+ * numbers.
+ *
+ * All operations maintain the non-positive constraint by clamping positive
+ * results to MAX_VALUE (0), while ensuring results remain finite (excluding NaN
+ * and Infinity). This type is useful for representing quantities that must
+ * always be non-positive, such as debts, penalties, and negative offsets.
+ */
+export declare const NonPositiveFiniteNumber: {
+    /**
+     * Type guard to check if a value is a NonPositiveFiniteNumber.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a non-positive finite number, `false`
+     *   otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NonPositiveFiniteNumber;
+    /**
+     * The maximum value for a non-positive finite number.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: 0;
+    /**
+     * Returns the smaller of two NonPositiveFiniteNumber values.
+     *
+     * @param a The first NonPositiveFiniteNumber.
+     * @param b The second NonPositiveFiniteNumber.
+     * @returns The minimum value as a NonPositiveFiniteNumber.
+     */
+    readonly min: (...values: readonly TtfImported_NonPositiveFiniteNumber[]) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Returns the larger of two NonPositiveFiniteNumber values.
+     *
+     * @param a The first NonPositiveFiniteNumber.
+     * @param b The second NonPositiveFiniteNumber.
+     * @returns The maximum value as a NonPositiveFiniteNumber.
+     */
+    readonly max: (...values: readonly TtfImported_NonPositiveFiniteNumber[]) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Clamps a number to the non-positive finite range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to (-∞, 0] as a NonPositiveFiniteNumber.
+     */
+    readonly clamp: (x: number) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Rounds down a NonPositiveFiniteNumber to the nearest integer.
+     *
+     * @param x The NonPositiveFiniteNumber to round down.
+     * @returns The floor value as a NonPositiveInt (can be 0).
+     */
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Rounds up a NonPositiveFiniteNumber to the nearest integer.
+     *
+     * @param x The NonPositiveFiniteNumber to round up.
+     * @returns The ceiling value as a NegativeInt (always <= -1) or 0.
+     */
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Rounds a NonPositiveFiniteNumber to the nearest integer.
+     *
+     * @param x The NonPositiveFiniteNumber to round.
+     * @returns The rounded value as a NonPositiveInt (can be 0 if x > -0.5).
+     */
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Generates a random NonPositiveFiniteNumber value.
+     *
+     * @returns A random non-positive finite number.
+     */
+    readonly random: (min?: TtfImported_NonPositiveFiniteNumber | undefined, max?: TtfImported_NonPositiveFiniteNumber | undefined) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Raises a NonPositiveFiniteNumber to the power of another NonPositiveFiniteNumber.
+     *
+     * @param a The base NonPositiveFiniteNumber.
+     * @param b The exponent NonPositiveFiniteNumber.
+     * @returns `a ** b` clamped to (-∞, 0] as a NonPositiveFiniteNumber.
+     */
+    readonly pow: (x: TtfImported_NonPositiveFiniteNumber, y: TtfImported_NonPositiveFiniteNumber) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Adds two NonPositiveFiniteNumber values.
+     *
+     * @param a The first NonPositiveFiniteNumber.
+     * @param b The second NonPositiveFiniteNumber.
+     * @returns `a + b` clamped to (-∞, 0] as a NonPositiveFiniteNumber.
+     */
+    readonly add: (x: TtfImported_NonPositiveFiniteNumber, y: TtfImported_NonPositiveFiniteNumber) => TtfImported_NonPositiveFiniteNumber;
+    /**
+     * Subtracts one NonPositiveFiniteNumber from another.
+     *
+     * @param a The minuend NonPositiveFiniteNumber.
+     * @param b The subtrahend NonPositiveFiniteNumber.
+     * @returns `a - b` clamped to (-∞, 0] as a NonPositiveFiniteNumber (maximum 0).
+     */
+    readonly sub: (x: TtfImported_NonPositiveFiniteNumber, y: TtfImported_NonPositiveFiniteNumber) => TtfImported_NonPositiveFiniteNumber;
+};
+export {};
+//# sourceMappingURL=non-positive-finite-number.d.mts.map

package/dist/number/branded-types/non-positive-finite-number.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,IAAI,mCAAmC,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2D3C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBA3GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA2GC;;;;;OAKG;uBAvGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAuGC;;;;;OAKG;wBArGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAqGC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}