ts-data-forge 6.9.1 → 6.9.3

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

@@ -1,3 +1,5 @@
+import { type NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
+export type NonNegativeInt16 = TtfImported_NonNegativeInt16;
 /**
  * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer
  * in the range [0, 2^15)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeInt16, `false` otherwise.
  */
-export declare const isNonNegativeInt16: (a: number) => a is NonNegativeInt16;
+export declare const isNonNegativeInt16: (a: number) => a is TtfImported_NonNegativeInt16;
 /**
  * Casts a number to a NonNegativeInt16 type.
  *
@@ -15,6 +17,8 @@ export declare const isNonNegativeInt16: (a: number) => a is NonNegativeInt16;
  */
 export declare const asNonNegativeInt16: <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 asNonNegativeInt16: <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;
@@ -47,7 +49,7 @@ export declare const NonNegativeInt16: {
      * @returns `true` if the value is a 16-bit non-negative integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is NonNegativeInt16;
+    readonly is: (a: number) => a is TtfImported_NonNegativeInt16;
     /**
      * The minimum value for a 16-bit non-negative integer.
      *
@@ -67,7 +69,7 @@ export declare const NonNegativeInt16: {
      * @param b The second NonNegativeInt16.
      * @returns The minimum value as a NonNegativeInt16.
      */
-    readonly min: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>[]) => TtfImported_NonNegativeInt16;
     /**
      * Returns the larger of two NonNegativeInt16 values.
      *
@@ -75,20 +77,20 @@ export declare const NonNegativeInt16: {
      * @param b The second NonNegativeInt16.
      * @returns The maximum value as a NonNegativeInt16.
      */
-    readonly max: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>[]) => TtfImported_NonNegativeInt16;
     /**
      * Clamps a number to the NonNegativeInt16 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 32767] as a NonNegativeInt16.
      */
-    readonly clamp: (x: number) => NonNegativeInt16;
+    readonly clamp: (x: number) => TtfImported_NonNegativeInt16;
     /**
      * Generates a random NonNegativeInt16 value within the valid range.
      *
      * @returns A random NonNegativeInt16 between 0 and 32767.
      */
-    readonly random: (min?: WithSmallInt<NonNegativeInt16, 40> | undefined, max?: WithSmallInt<NonNegativeInt16, 40> | undefined) => NonNegativeInt16;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16> | undefined) => TtfImported_NonNegativeInt16;
     /**
      * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
      *
@@ -96,7 +98,7 @@ export declare const NonNegativeInt16: {
      * @param b The exponent NonNegativeInt16.
      * @returns `a ** b` clamped to [0, 32767] as a NonNegativeInt16.
      */
-    readonly pow: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>) => TtfImported_NonNegativeInt16;
     /**
      * Adds two NonNegativeInt16 values.
      *
@@ -104,7 +106,7 @@ export declare const NonNegativeInt16: {
      * @param b The second NonNegativeInt16.
      * @returns `a + b` clamped to [0, 32767] as a NonNegativeInt16.
      */
-    readonly add: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>) => TtfImported_NonNegativeInt16;
     /**
      * Subtracts one NonNegativeInt16 from another.
      *
@@ -112,7 +114,7 @@ export declare const NonNegativeInt16: {
      * @param b The subtrahend NonNegativeInt16.
      * @returns `a - b` clamped to [0, 32767] as a NonNegativeInt16 (minimum 0).
      */
-    readonly sub: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>) => TtfImported_NonNegativeInt16;
     /**
      * Multiplies two NonNegativeInt16 values.
      *
@@ -120,7 +122,7 @@ export declare const NonNegativeInt16: {
      * @param b The second NonNegativeInt16.
      * @returns `a * b` clamped to [0, 32767] as a NonNegativeInt16.
      */
-    readonly mul: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>) => TtfImported_NonNegativeInt16;
     /**
      * Divides one NonNegativeInt16 by another using floor division.
      *
@@ -128,8 +130,10 @@ export declare const NonNegativeInt16: {
      * @param b The divisor NonNegativeInt16.
      * @returns `⌊a / b⌋` clamped to [0, 32767] as a NonNegativeInt16.
      */
-    readonly div: (x: WithSmallInt<NonNegativeInt16, 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 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt16>, 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 | 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;
@@ -140,11 +144,9 @@ export declare const NonNegativeInt16: {
         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;
-    }>>) => NonNegativeInt16;
+    }>>) => TtfImported_NonNegativeInt16;
 };
 //# sourceMappingURL=non-negative-int16.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAItF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AA+B5D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,kDAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;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/non-negative-int16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.mjs","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;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":"non-negative-int16.mjs","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;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-int32.d.mts

@@ -1,3 +1,5 @@
+import { type NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
+export type NonNegativeInt32 = TtfImported_NonNegativeInt32;
 /**
  * Checks if a number is a NonNegativeInt32 (32-bit non-negative signed integer
  * in the range [0, 2^31)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeInt32, `false` otherwise.
  */
-export declare const isNonNegativeInt32: (a: number) => a is NonNegativeInt32;
+export declare const isNonNegativeInt32: (a: number) => a is TtfImported_NonNegativeInt32;
 /**
  * Casts a number to a NonNegativeInt32 type.
  *
@@ -15,6 +17,8 @@ export declare const isNonNegativeInt32: (a: number) => a is NonNegativeInt32;
  */
 export declare const asNonNegativeInt32: <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;
@@ -22,8 +26,6 @@ export declare const asNonNegativeInt32: <N extends number>(x: N) => number & {
     readonly ">=0": 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 NonNegativeInt32: {
      * @returns `true` if the value is a 32-bit non-negative integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is NonNegativeInt32;
+    readonly is: (a: number) => a is TtfImported_NonNegativeInt32;
     /**
      * The minimum value for a 32-bit non-negative integer.
      *
@@ -65,7 +67,7 @@ export declare const NonNegativeInt32: {
      * @param b The second NonNegativeInt32.
      * @returns The minimum value as a NonNegativeInt32.
      */
-    readonly min: (...values: readonly WithSmallInt<NonNegativeInt32, 40>[]) => NonNegativeInt32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>[]) => TtfImported_NonNegativeInt32;
     /**
      * Returns the larger of two NonNegativeInt32 values.
      *
@@ -73,20 +75,20 @@ export declare const NonNegativeInt32: {
      * @param b The second NonNegativeInt32.
      * @returns The maximum value as a NonNegativeInt32.
      */
-    readonly max: (...values: readonly WithSmallInt<NonNegativeInt32, 40>[]) => NonNegativeInt32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>[]) => TtfImported_NonNegativeInt32;
     /**
      * Clamps a number to the NonNegativeInt32 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 2147483647] as a NonNegativeInt32.
      */
-    readonly clamp: (x: number) => NonNegativeInt32;
+    readonly clamp: (x: number) => TtfImported_NonNegativeInt32;
     /**
      * Generates a random NonNegativeInt32 value within the valid range.
      *
      * @returns A random NonNegativeInt32 between 0 and 2147483647.
      */
-    readonly random: (min?: WithSmallInt<NonNegativeInt32, 40> | undefined, max?: WithSmallInt<NonNegativeInt32, 40> | undefined) => NonNegativeInt32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32> | undefined) => TtfImported_NonNegativeInt32;
     /**
      * Raises a NonNegativeInt32 to the power of another NonNegativeInt32.
      *
@@ -94,7 +96,7 @@ export declare const NonNegativeInt32: {
      * @param b The exponent NonNegativeInt32.
      * @returns `a ** b` clamped to [0, 2147483647] as a NonNegativeInt32.
      */
-    readonly pow: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>) => TtfImported_NonNegativeInt32;
     /**
      * Adds two NonNegativeInt32 values.
      *
@@ -102,7 +104,7 @@ export declare const NonNegativeInt32: {
      * @param b The second NonNegativeInt32.
      * @returns `a + b` clamped to [0, 2147483647] as a NonNegativeInt32.
      */
-    readonly add: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>) => TtfImported_NonNegativeInt32;
     /**
      * Subtracts one NonNegativeInt32 from another.
      *
@@ -111,7 +113,7 @@ export declare const NonNegativeInt32: {
      * @returns `a - b` clamped to [0, 2147483647] as a NonNegativeInt32 (minimum
      *   0).
      */
-    readonly sub: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>) => TtfImported_NonNegativeInt32;
     /**
      * Multiplies two NonNegativeInt32 values.
      *
@@ -119,7 +121,7 @@ export declare const NonNegativeInt32: {
      * @param b The second NonNegativeInt32.
      * @returns `a * b` clamped to [0, 2147483647] as a NonNegativeInt32.
      */
-    readonly mul: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>) => TtfImported_NonNegativeInt32;
     /**
      * Divides one NonNegativeInt32 by another using floor division.
      *
@@ -127,8 +129,10 @@ export declare const NonNegativeInt32: {
      * @param b The divisor NonNegativeInt32.
      * @returns `⌊a / b⌋` clamped to [0, 2147483647] as a NonNegativeInt32.
      */
-    readonly div: (x: WithSmallInt<NonNegativeInt32, 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 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonNegativeInt32>, 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 | 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;
@@ -137,11 +141,9 @@ export declare const NonNegativeInt32: {
         readonly ">=0": 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;
-    }>>) => NonNegativeInt32;
+    }>>) => TtfImported_NonNegativeInt32;
 };
 //# sourceMappingURL=non-negative-int32.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAItF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AA+B5D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,kDAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;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;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;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;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,6 @@
+import { type NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;
 type ElementType = NonZeroFiniteNumber;
 /**
  * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
@@ -6,7 +8,7 @@ type ElementType = NonZeroFiniteNumber;
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
  */
-export declare const isNonZeroFiniteNumber: (a: number) => a is NonZeroFiniteNumber;
+export declare const isNonZeroFiniteNumber: (a: number) => a is TtfImported_NonZeroFiniteNumber;
 /**
  * Casts a number to a NonZeroFiniteNumber type.
  *
@@ -16,8 +18,8 @@ export declare const isNonZeroFiniteNumber: (a: number) => a is NonZeroFiniteNum
  */
 export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
-    readonly "!=0": true;
     readonly Finite: true;
+    readonly "!=0": true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -37,14 +39,14 @@ export declare const NonZeroFiniteNumber: {
      * @returns `true` if the value is a non-zero finite number, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is NonZeroFiniteNumber;
+    readonly is: (a: number) => a is TtfImported_NonZeroFiniteNumber;
     /**
      * Returns the absolute value of a non-zero finite number.
      *
      * @param a The NonZeroFiniteNumber.
      * @returns The absolute value as a NonZeroFiniteNumber.
      */
-    readonly abs: (x: NonZeroFiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroFiniteNumber>;
+    readonly abs: (x: TtfImported_NonZeroFiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_NonZeroFiniteNumber>;
     /**
      * Returns the smaller of two NonZeroFiniteNumber values.
      *
@@ -52,7 +54,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The second NonZeroFiniteNumber.
      * @returns The minimum value as a NonZeroFiniteNumber.
      */
-    readonly min: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
+    readonly min: (...values: readonly TtfImported_NonZeroFiniteNumber[]) => TtfImported_NonZeroFiniteNumber;
     /**
      * Returns the larger of two NonZeroFiniteNumber values.
      *
@@ -60,7 +62,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The second NonZeroFiniteNumber.
      * @returns The maximum value as a NonZeroFiniteNumber.
      */
-    readonly max: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
+    readonly max: (...values: readonly TtfImported_NonZeroFiniteNumber[]) => TtfImported_NonZeroFiniteNumber;
     /**
      * Rounds down a NonZeroFiniteNumber to the nearest integer.
      *
@@ -87,7 +89,7 @@ export declare const NonZeroFiniteNumber: {
      *
      * @returns A random non-zero finite number.
      */
-    readonly random: (min?: NonZeroFiniteNumber | undefined, max?: NonZeroFiniteNumber | undefined) => NonZeroFiniteNumber;
+    readonly random: (min?: TtfImported_NonZeroFiniteNumber | undefined, max?: TtfImported_NonZeroFiniteNumber | undefined) => TtfImported_NonZeroFiniteNumber;
     /**
      * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
      *
@@ -95,7 +97,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The exponent NonZeroFiniteNumber.
      * @returns `a ** b` as a NonZeroFiniteNumber.
      */
-    readonly pow: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    readonly pow: (x: TtfImported_NonZeroFiniteNumber, y: TtfImported_NonZeroFiniteNumber) => TtfImported_NonZeroFiniteNumber;
     /**
      * Adds two NonZeroFiniteNumber values.
      *
@@ -103,7 +105,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The second NonZeroFiniteNumber.
      * @returns `a + b` as a NonZeroFiniteNumber.
      */
-    readonly add: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    readonly add: (x: TtfImported_NonZeroFiniteNumber, y: TtfImported_NonZeroFiniteNumber) => TtfImported_NonZeroFiniteNumber;
     /**
      * Subtracts one NonZeroFiniteNumber from another.
      *
@@ -111,7 +113,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The subtrahend NonZeroFiniteNumber.
      * @returns `a - b` as a NonZeroFiniteNumber.
      */
-    readonly sub: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    readonly sub: (x: TtfImported_NonZeroFiniteNumber, y: TtfImported_NonZeroFiniteNumber) => TtfImported_NonZeroFiniteNumber;
     /**
      * Multiplies two NonZeroFiniteNumber values.
      *
@@ -119,7 +121,7 @@ export declare const NonZeroFiniteNumber: {
      * @param b The second NonZeroFiniteNumber.
      * @returns `a * b` as a NonZeroFiniteNumber.
      */
-    readonly mul: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    readonly mul: (x: TtfImported_NonZeroFiniteNumber, y: TtfImported_NonZeroFiniteNumber) => TtfImported_NonZeroFiniteNumber;
     /**
      * Divides one NonZeroFiniteNumber by another.
      *
@@ -127,13 +129,13 @@ export declare const NonZeroFiniteNumber: {
      * @param b The divisor NonZeroFiniteNumber.
      * @returns `a / b` as a NonZeroFiniteNumber.
      */
-    readonly div: (x: NonZeroFiniteNumber, y: number & {
+    readonly div: (x: TtfImported_NonZeroFiniteNumber, y: number & {
         readonly NaNValue: false;
-        readonly "!=0": true;
         readonly Finite: true;
+        readonly "!=0": true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>) => NonZeroFiniteNumber;
+    }>) => TtfImported_NonZeroFiniteNumber;
 };
 export {};
 //# sourceMappingURL=non-zero-finite-number.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;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;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,IAAI,+BAA+B,EAC5D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;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;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,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;AAc7E;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;AAOG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;;;AAMG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;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":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAaA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,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;AAc7E;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;AAOG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;;;AAMG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;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-zero-int.d.mts

@@ -1,11 +1,13 @@
+import { type NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonZeroInt = TtfImported_NonZeroInt;
 /**
  * Checks if a number is a NonZeroInt.
  *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt, `false` otherwise.
  */
-export declare const isNonZeroInt: (a: number) => a is NonZeroInt;
+export declare const isNonZeroInt: (a: number) => a is TtfImported_NonZeroInt;
 /**
  * Casts a number to a NonZeroInt type.
  *
@@ -15,9 +17,9 @@ export declare const isNonZeroInt: (a: number) => a is NonZeroInt;
  */
 export declare const asNonZeroInt: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
-    readonly "!=0": true;
     readonly Finite: true;
     readonly Int: true;
+    readonly "!=0": true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -35,14 +37,14 @@ export declare const NonZeroInt: {
      * @param value The value to check.
      * @returns `true` if the value is a non-zero integer, `false` otherwise.
      */
-    readonly is: (a: number) => a is NonZeroInt;
+    readonly is: (a: number) => a is TtfImported_NonZeroInt;
     /**
      * Returns the absolute value of a non-zero integer.
      *
      * @param a The non-zero integer.
      * @returns The absolute value as a NonZeroInt.
      */
-    readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_NonZeroInt>;
     /**
      * Returns the smaller of two non-zero integers.
      *
@@ -50,7 +52,7 @@ export declare const NonZeroInt: {
      * @param b The second non-zero integer.
      * @returns The minimum value as a NonZeroInt.
      */
-    readonly min: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>[]) => TtfImported_NonZeroInt;
     /**
      * Returns the larger of two non-zero integers.
      *
@@ -58,13 +60,13 @@ export declare const NonZeroInt: {
      * @param b The second non-zero integer.
      * @returns The maximum value as a NonZeroInt.
      */
-    readonly max: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>[]) => TtfImported_NonZeroInt;
     /**
      * Generates a random non-zero integer.
      *
      * @returns A random NonZeroInt value.
      */
-    readonly random: (min?: WithSmallInt<NonZeroInt, 40> | undefined, max?: WithSmallInt<NonZeroInt, 40> | undefined) => NonZeroInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt> | undefined) => TtfImported_NonZeroInt;
     /**
      * Raises a non-zero integer to the power of another non-zero integer.
      *
@@ -72,7 +74,7 @@ export declare const NonZeroInt: {
      * @param b The exponent non-zero integer.
      * @returns `a ** b` as a NonZeroInt.
      */
-    readonly pow: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>) => TtfImported_NonZeroInt;
     /**
      * Adds two non-zero integers.
      *
@@ -80,7 +82,7 @@ export declare const NonZeroInt: {
      * @param b The second non-zero integer.
      * @returns `a + b` as a NonZeroInt.
      */
-    readonly add: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>) => TtfImported_NonZeroInt;
     /**
      * Subtracts one non-zero integer from another.
      *
@@ -88,7 +90,7 @@ export declare const NonZeroInt: {
      * @param b The subtrahend non-zero integer.
      * @returns `a - b` as a NonZeroInt.
      */
-    readonly sub: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>) => TtfImported_NonZeroInt;
     /**
      * Multiplies two non-zero integers.
      *
@@ -96,7 +98,7 @@ export declare const NonZeroInt: {
      * @param b The second non-zero integer.
      * @returns `a * b` as a NonZeroInt.
      */
-    readonly mul: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt>) => TtfImported_NonZeroInt;
     /**
      * Divides one non-zero integer by another using floor division.
      *
@@ -104,13 +106,13 @@ export declare const NonZeroInt: {
      * @param b The divisor non-zero integer.
      * @returns `⌊a / b⌋` as a NonZeroInt.
      */
-    readonly div: (x: WithSmallInt<NonZeroInt, 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_NonZeroInt>, 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;
-    }>>) => NonZeroInt;
+    }>>) => TtfImported_NonZeroInt;
 };
 //# sourceMappingURL=non-zero-int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,IAAI,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AA8BhD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,4CAAK,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,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,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;AAKG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AACxB;;;;;AAKG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;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":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,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,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;AAKG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AACxB;;;;;AAKG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}