ts-data-forge 6.9.1 → 6.9.3

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

@@ -1,4 +1,6 @@
+import { type Int as TtfImported_Int } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type Int = TtfImported_Int;
 /**
  * Type guard that checks if a value is an integer.
  *
@@ -19,7 +21,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value - The value to check
  * @returns `true` if the value is an integer, `false` otherwise
  */
-export declare const isInt: (a: number) => a is Int;
+export declare const isInt: (a: number) => a is TtfImported_Int;
 /**
  * Casts a number to an Int branded type.
  *
@@ -77,7 +79,7 @@ export declare const Int: {
      * @returns `true` if the value is an integer, `false` otherwise
      * @see {@link isInt} for usage examples
      */
-    readonly is: (a: number) => a is Int;
+    readonly is: (a: number) => a is TtfImported_Int;
     /**
      * Returns the absolute value of an integer.
      *
@@ -100,7 +102,7 @@ export declare const Int: {
      * @param a - The integer value
      * @returns The absolute value as a non-negative Int
      */
-    readonly abs: (x: WithSmallInt<Int, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int>;
     /**
      * Returns the minimum value from a list of integers.
      *
@@ -115,7 +117,7 @@ export declare const Int: {
      * @param values - The integers to compare (at least one required)
      * @returns The smallest value as an Int
      */
-    readonly min: (...values: readonly WithSmallInt<Int, 40>[]) => Int;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int>[]) => TtfImported_Int;
     /**
      * Returns the maximum value from a list of integers.
      *
@@ -130,7 +132,7 @@ export declare const Int: {
      * @param values - The integers to compare (at least one required)
      * @returns The largest value as an Int
      */
-    readonly max: (...values: readonly WithSmallInt<Int, 40>[]) => Int;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int>[]) => TtfImported_Int;
     /**
      * Generates a random integer within the specified range (inclusive).
      *
@@ -155,7 +157,7 @@ export declare const Int: {
      * @param max - The maximum value (inclusive)
      * @returns A random Int in the range [min, max]
      */
-    readonly random: (min?: WithSmallInt<Int, 40> | undefined, max?: WithSmallInt<Int, 40> | undefined) => Int;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_Int> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_Int> | undefined) => TtfImported_Int;
     /**
      * Raises an integer to a power.
      *
@@ -175,7 +177,7 @@ export declare const Int: {
      * @param b - The exponent integer
      * @returns `a ** b` as an Int
      */
-    readonly pow: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TtfImported_Int;
     /**
      * Adds two integers.
      *
@@ -191,7 +193,7 @@ export declare const Int: {
      * @param b - Second integer
      * @returns `a + b` as an Int
      */
-    readonly add: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TtfImported_Int;
     /**
      * Subtracts two integers.
      *
@@ -207,7 +209,7 @@ export declare const Int: {
      * @param b - Second integer
      * @returns `a - b` as an Int
      */
-    readonly sub: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TtfImported_Int;
     /**
      * Multiplies two integers.
      *
@@ -223,7 +225,7 @@ export declare const Int: {
      * @param b - Second integer
      * @returns `a * b` as an Int
      */
-    readonly mul: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TtfImported_Int;
     /**
      * Divides two integers using floor division.
      *
@@ -246,13 +248,13 @@ export declare const Int: {
      * @param b - The divisor (must be non-zero)
      * @returns The integer quotient as an Int
      */
-    readonly div: (x: WithSmallInt<Int, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -24 | -14 | -34 | -12 | -13 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -25 | -26 | -27 | -28 | -29 | -30 | -31 | -33 | -35 | -36 | -37 | -38 | -39 | -40 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -40 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -20 | -30 | -12 | -13 | -14 | -15 | -16 | -17 | -18 | -19 | -21 | -22 | -23 | -24 | -25 | -26 | -27 | -28 | -29 | -31 | -33 | -34 | -35 | -36 | -37 | -38 | -39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
-        readonly "!=0": true;
         readonly Finite: true;
         readonly Int: true;
+        readonly "!=0": true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => Int;
+    }>>) => TtfImported_Int;
 };
 //# sourceMappingURL=int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6BnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,GAAG,GAAG,eAAe,CAAC;AA6BlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,qCAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;AAUG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;AAUG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,6 @@
+import { type Int16 as TtfImported_Int16 } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type Int16 = TtfImported_Int16;
 /**
  * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15,
  * 2^15)).
@@ -6,7 +8,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value The value to check.
  * @returns `true` if the value is an Int16, `false` otherwise.
  */
-export declare const isInt16: (a: number) => a is Int16;
+export declare const isInt16: (a: number) => a is TtfImported_Int16;
 /**
  * Casts a number to an Int16 type.
  *
@@ -16,6 +18,8 @@ export declare const isInt16: (a: number) => a is Int16;
  */
 export declare const asInt16: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
@@ -24,8 +28,6 @@ export declare const asInt16: <N extends number>(x: N) => number & {
     readonly "< 2^16": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -45,7 +47,7 @@ export declare const Int16: {
      * @param value The value to check.
      * @returns `true` if the value is a 16-bit signed integer, `false` otherwise.
      */
-    readonly is: (a: number) => a is Int16;
+    readonly is: (a: number) => a is TtfImported_Int16;
     /**
      * The minimum value for a 16-bit signed integer.
      *
@@ -64,7 +66,7 @@ export declare const Int16: {
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<Int16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int16>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int16>;
     /**
      * Returns the smaller of two Int16 values.
      *
@@ -72,7 +74,7 @@ export declare const Int16: {
      * @param b The second Int16.
      * @returns The minimum value as an Int16.
      */
-    readonly min: (...values: readonly WithSmallInt<Int16, 40>[]) => Int16;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int16>[]) => TtfImported_Int16;
     /**
      * Returns the larger of two Int16 values.
      *
@@ -80,20 +82,20 @@ export declare const Int16: {
      * @param b The second Int16.
      * @returns The maximum value as an Int16.
      */
-    readonly max: (...values: readonly WithSmallInt<Int16, 40>[]) => Int16;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int16>[]) => TtfImported_Int16;
     /**
      * Clamps a number to the Int16 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [-32768, 32767] as an Int16.
      */
-    readonly clamp: (x: number) => Int16;
+    readonly clamp: (x: number) => TtfImported_Int16;
     /**
      * Generates a random Int16 value within the valid range.
      *
      * @returns A random Int16 between MIN_VALUE and MAX_VALUE.
      */
-    readonly random: (min?: WithSmallInt<Int16, 40> | undefined, max?: WithSmallInt<Int16, 40> | undefined) => Int16;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_Int16> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_Int16> | undefined) => TtfImported_Int16;
     /**
      * Raises an Int16 to the power of another Int16.
      *
@@ -101,7 +103,7 @@ export declare const Int16: {
      * @param b The exponent Int16.
      * @returns `a ** b` clamped to [-32768, 32767] as an Int16.
      */
-    readonly pow: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TtfImported_Int16;
     /**
      * Adds two Int16 values.
      *
@@ -109,7 +111,7 @@ export declare const Int16: {
      * @param b The second Int16.
      * @returns `a + b` clamped to [-32768, 32767] as an Int16.
      */
-    readonly add: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TtfImported_Int16;
     /**
      * Subtracts one Int16 from another.
      *
@@ -117,7 +119,7 @@ export declare const Int16: {
      * @param b The subtrahend Int16.
      * @returns `a - b` clamped to [-32768, 32767] as an Int16.
      */
-    readonly sub: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TtfImported_Int16;
     /**
      * Multiplies two Int16 values.
      *
@@ -125,7 +127,7 @@ export declare const Int16: {
      * @param b The second Int16.
      * @returns `a * b` clamped to [-32768, 32767] as an Int16.
      */
-    readonly mul: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TtfImported_Int16;
     /**
      * Divides one Int16 by another using floor division.
      *
@@ -133,8 +135,10 @@ export declare const Int16: {
      * @param b The divisor Int16.
      * @returns `⌊a / b⌋` clamped to [-32768, 32767] as an Int16.
      */
-    readonly div: (x: WithSmallInt<Int16, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -24 | -14 | -34 | -12 | -13 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -25 | -26 | -27 | -28 | -29 | -30 | -31 | -33 | -35 | -36 | -37 | -38 | -39 | -40 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -40 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -20 | -30 | -12 | -13 | -14 | -15 | -16 | -17 | -18 | -19 | -21 | -22 | -23 | -24 | -25 | -26 | -27 | -28 | -29 | -31 | -33 | -34 | -35 | -36 | -37 | -38 | -39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
@@ -144,11 +148,9 @@ export declare const Int16: {
         readonly "< 2^16": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => Int16;
+    }>>) => TtfImported_Int16;
 };
 //# sourceMappingURL=int16.d.mts.map

package/dist/number/branded-types/int16.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,6 @@
+import { type Int32 as TtfImported_Int32 } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type Int32 = TtfImported_Int32;
 /**
  * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31,
  * 2^31)).
@@ -6,7 +8,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value The value to check.
  * @returns `true` if the value is an Int32, `false` otherwise.
  */
-export declare const isInt32: (a: number) => a is Int32;
+export declare const isInt32: (a: number) => a is TtfImported_Int32;
 /**
  * Casts a number to an Int32 type.
  *
@@ -16,12 +18,12 @@ export declare const isInt32: (a: number) => a is Int32;
  */
 export declare const asInt32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^32": true;
     readonly ">= -2^31": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -41,7 +43,7 @@ export declare const Int32: {
      * @param value The value to check.
      * @returns `true` if the value is a 32-bit signed integer, `false` otherwise.
      */
-    readonly is: (a: number) => a is Int32;
+    readonly is: (a: number) => a is TtfImported_Int32;
     /**
      * The minimum value for a 32-bit signed integer.
      *
@@ -60,7 +62,7 @@ export declare const Int32: {
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<Int32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int32>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int32>;
     /**
      * Returns the smaller of two Int32 values.
      *
@@ -68,7 +70,7 @@ export declare const Int32: {
      * @param b The second Int32.
      * @returns The minimum value as an Int32.
      */
-    readonly min: (...values: readonly WithSmallInt<Int32, 40>[]) => Int32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int32>[]) => TtfImported_Int32;
     /**
      * Returns the larger of two Int32 values.
      *
@@ -76,20 +78,20 @@ export declare const Int32: {
      * @param b The second Int32.
      * @returns The maximum value as an Int32.
      */
-    readonly max: (...values: readonly WithSmallInt<Int32, 40>[]) => Int32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Int32>[]) => TtfImported_Int32;
     /**
      * Clamps a number to the Int32 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly clamp: (x: number) => Int32;
+    readonly clamp: (x: number) => TtfImported_Int32;
     /**
      * Generates a random Int32 value within the valid range.
      *
      * @returns A random Int32 between MIN_VALUE and MAX_VALUE.
      */
-    readonly random: (min?: WithSmallInt<Int32, 40> | undefined, max?: WithSmallInt<Int32, 40> | undefined) => Int32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_Int32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_Int32> | undefined) => TtfImported_Int32;
     /**
      * Raises an Int32 to the power of another Int32.
      *
@@ -97,7 +99,7 @@ export declare const Int32: {
      * @param b The exponent Int32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly pow: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TtfImported_Int32;
     /**
      * Adds two Int32 values.
      *
@@ -105,7 +107,7 @@ export declare const Int32: {
      * @param b The second Int32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly add: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TtfImported_Int32;
     /**
      * Subtracts one Int32 from another.
      *
@@ -113,7 +115,7 @@ export declare const Int32: {
      * @param b The subtrahend Int32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly sub: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TtfImported_Int32;
     /**
      * Multiplies two Int32 values.
      *
@@ -121,7 +123,7 @@ export declare const Int32: {
      * @param b The second Int32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly mul: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TtfImported_Int32;
     /**
      * Divides one Int32 by another using floor division.
      *
@@ -129,18 +131,18 @@ export declare const Int32: {
      * @param b The divisor Int32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as an Int32.
      */
-    readonly div: (x: WithSmallInt<Int32, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -24 | -14 | -34 | -12 | -13 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -25 | -26 | -27 | -28 | -29 | -30 | -31 | -33 | -35 | -36 | -37 | -38 | -39 | -40 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -40 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -20 | -30 | -12 | -13 | -14 | -15 | -16 | -17 | -18 | -19 | -21 | -22 | -23 | -24 | -25 | -26 | -27 | -28 | -29 | -31 | -33 | -34 | -35 | -36 | -37 | -38 | -39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^32": true;
         readonly ">= -2^31": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => Int32;
+    }>>) => TtfImported_Int32;
 };
 //# sourceMappingURL=int32.d.mts.map

package/dist/number/branded-types/int32.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,6 @@
+import { type NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
 type ElementType = NonNegativeFiniteNumber;
 /**
  * Checks if a number is a NonNegativeFiniteNumber (a finite number >= 0).
@@ -6,7 +8,7 @@ type ElementType = NonNegativeFiniteNumber;
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeFiniteNumber, `false` otherwise.
  */
-export declare const isNonNegativeFiniteNumber: (a: number) => a is NonNegativeFiniteNumber;
+export declare const isNonNegativeFiniteNumber: (a: number) => a is TtfImported_NonNegativeFiniteNumber;
 /**
  * Casts a number to a NonNegativeFiniteNumber type.
  *
@@ -16,12 +18,12 @@ export declare const isNonNegativeFiniteNumber: (a: number) => a is NonNegativeF
  */
 export declare const asNonNegativeFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
     readonly ">= -2^31": true;
     readonly ">=0": true;
-    readonly Finite: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -42,7 +44,7 @@ export declare const NonNegativeFiniteNumber: {
      * @returns `true` if the value is a non-negative finite number, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is NonNegativeFiniteNumber;
+    readonly is: (a: number) => a is TtfImported_NonNegativeFiniteNumber;
     /**
      * The minimum value for a non-negative finite number.
      *
@@ -56,7 +58,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The second NonNegativeFiniteNumber.
      * @returns The minimum value as a NonNegativeFiniteNumber.
      */
-    readonly min: (...values: readonly NonNegativeFiniteNumber[]) => NonNegativeFiniteNumber;
+    readonly min: (...values: readonly TtfImported_NonNegativeFiniteNumber[]) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Returns the larger of two NonNegativeFiniteNumber values.
      *
@@ -64,14 +66,14 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The second NonNegativeFiniteNumber.
      * @returns The maximum value as a NonNegativeFiniteNumber.
      */
-    readonly max: (...values: readonly NonNegativeFiniteNumber[]) => NonNegativeFiniteNumber;
+    readonly max: (...values: readonly TtfImported_NonNegativeFiniteNumber[]) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Clamps a number to the non-negative finite range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
-    readonly clamp: (x: number) => NonNegativeFiniteNumber;
+    readonly clamp: (x: number) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Rounds down a NonNegativeFiniteNumber to the nearest integer.
      *
@@ -98,7 +100,7 @@ export declare const NonNegativeFiniteNumber: {
      *
      * @returns A random non-negative finite number.
      */
-    readonly random: (min?: NonNegativeFiniteNumber | undefined, max?: NonNegativeFiniteNumber | undefined) => NonNegativeFiniteNumber;
+    readonly random: (min?: TtfImported_NonNegativeFiniteNumber | undefined, max?: TtfImported_NonNegativeFiniteNumber | undefined) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Raises a NonNegativeFiniteNumber to the power of another
      * NonNegativeFiniteNumber.
@@ -107,7 +109,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The exponent NonNegativeFiniteNumber.
      * @returns `a ** b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
-    readonly pow: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
+    readonly pow: (x: TtfImported_NonNegativeFiniteNumber, y: TtfImported_NonNegativeFiniteNumber) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Adds two NonNegativeFiniteNumber values.
      *
@@ -115,7 +117,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a + b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
-    readonly add: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
+    readonly add: (x: TtfImported_NonNegativeFiniteNumber, y: TtfImported_NonNegativeFiniteNumber) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Subtracts one NonNegativeFiniteNumber from another.
      *
@@ -124,7 +126,7 @@ export declare const NonNegativeFiniteNumber: {
      * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum
      *   0).
      */
-    readonly sub: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
+    readonly sub: (x: TtfImported_NonNegativeFiniteNumber, y: TtfImported_NonNegativeFiniteNumber) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Multiplies two NonNegativeFiniteNumber values.
      *
@@ -132,7 +134,7 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a * b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
-    readonly mul: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
+    readonly mul: (x: TtfImported_NonNegativeFiniteNumber, y: TtfImported_NonNegativeFiniteNumber) => TtfImported_NonNegativeFiniteNumber;
     /**
      * Divides one NonNegativeFiniteNumber by another.
      *
@@ -140,18 +142,18 @@ export declare const NonNegativeFiniteNumber: {
      * @param b The divisor NonNegativeFiniteNumber.
      * @returns `a / b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
-    readonly div: (x: NonNegativeFiniteNumber, y: number & {
+    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 Finite: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>) => NonNegativeFiniteNumber;
+    }>) => TtfImported_NonNegativeFiniteNumber;
 };
 export {};
 //# sourceMappingURL=non-negative-finite-number.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,6CAAK,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;wBA/FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiG3D;;;;;OAKG;uBAjGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmG3D;;;;;OAKG;wBAnGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqG3D;;;;OAIG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,IAAI,mCAAmC,EAEpE,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;;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;wBA/FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiG3D;;;;;OAKG;uBAjGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmG3D;;;;;OAKG;wBAnGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqG3D;;;;OAIG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/non-negative-finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;;AAKG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;AAMG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;AAQG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAWA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;;AAKG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;AAMG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;AAQG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}