ts-data-forge 6.9.2 → 6.9.4

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

@@ -1,3 +1,5 @@
+import { type SafeUint, type PositiveSafeInt as TtfImported_PositiveSafeInt } from 'ts-type-forge';
+export type PositiveSafeInt = TtfImported_PositiveSafeInt;
 /**
  * Checks if a number is a PositiveSafeInt (a positive safe integer in the range
  * [1, MAX_SAFE_INTEGER]).
@@ -17,7 +19,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a PositiveSafeInt, `false` otherwise.
  */
-export declare const isPositiveSafeInt: (a: number) => a is PositiveSafeInt;
+export declare const isPositiveSafeInt: (a: number) => a is TtfImported_PositiveSafeInt;
 /**
  * Casts a number to a PositiveSafeInt type.
  *
@@ -37,14 +39,14 @@ export declare const isPositiveSafeInt: (a: number) => a is PositiveSafeInt;
  */
 export declare const asPositiveSafeInt: <N extends number>(x: N) => number & {
     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 Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -78,7 +80,7 @@ export declare const PositiveSafeInt: {
      * @returns `true` if the value is a positive safe integer, `false` otherwise.
      * @see {@link isPositiveSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is PositiveSafeInt;
+    readonly is: (a: number) => a is TtfImported_PositiveSafeInt;
     /**
      * The minimum value for a positive safe integer.
      *
@@ -109,7 +111,7 @@ export declare const PositiveSafeInt: {
      * @param b The second PositiveSafeInt.
      * @returns The minimum value as a PositiveSafeInt.
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveSafeInt, 40>[]) => PositiveSafeInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>[]) => TtfImported_PositiveSafeInt;
     /**
      * Returns the larger of two PositiveSafeInt values.
      *
@@ -128,7 +130,7 @@ export declare const PositiveSafeInt: {
      * @param b The second PositiveSafeInt.
      * @returns The maximum value as a PositiveSafeInt.
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveSafeInt, 40>[]) => PositiveSafeInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>[]) => TtfImported_PositiveSafeInt;
     /**
      * Clamps a number to the positive safe integer range.
      *
@@ -151,7 +153,7 @@ export declare const PositiveSafeInt: {
      * @param value The number to clamp.
      * @returns The value clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
      */
-    readonly clamp: (x: number) => PositiveSafeInt;
+    readonly clamp: (x: number) => TtfImported_PositiveSafeInt;
     /**
      * Generates a random PositiveSafeInt value within the valid range.
      *
@@ -171,7 +173,7 @@ export declare const PositiveSafeInt: {
      *
      * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
      */
-    readonly random: (min?: WithSmallInt<PositiveSafeInt, 40> | undefined, max?: WithSmallInt<PositiveSafeInt, 40> | undefined) => PositiveSafeInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt> | undefined) => TtfImported_PositiveSafeInt;
     /**
      * Raises a PositiveSafeInt to the power of another PositiveSafeInt.
      *
@@ -191,7 +193,7 @@ export declare const PositiveSafeInt: {
      * @param b The exponent PositiveSafeInt.
      * @returns `a ** b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
      */
-    readonly pow: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>) => TtfImported_PositiveSafeInt;
     /**
      * Adds two PositiveSafeInt values.
      *
@@ -212,7 +214,7 @@ export declare const PositiveSafeInt: {
      * @param b The second PositiveSafeInt.
      * @returns `a + b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
      */
-    readonly add: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>) => TtfImported_PositiveSafeInt;
     /**
      * Subtracts one PositiveSafeInt from another.
      *
@@ -234,7 +236,7 @@ export declare const PositiveSafeInt: {
      * @returns `a - b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt
      *   (minimum 1).
      */
-    readonly sub: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>) => TtfImported_PositiveSafeInt;
     /**
      * Multiplies two PositiveSafeInt values.
      *
@@ -255,7 +257,7 @@ export declare const PositiveSafeInt: {
      * @param b The second PositiveSafeInt.
      * @returns `a * b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
      */
-    readonly mul: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveSafeInt>) => TtfImported_PositiveSafeInt;
     /**
      * Divides one PositiveSafeInt by another using floor division.
      *
@@ -281,19 +283,19 @@ export declare const PositiveSafeInt: {
      * @param b The divisor PositiveSafeInt.
      * @returns `⌊a / b⌋` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
      */
-    readonly div: (x: WithSmallInt<PositiveSafeInt, 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_PositiveSafeInt>, 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;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => PositiveSafeInt;
+    }>>) => TtfImported_PositiveSafeInt;
 };
 //# sourceMappingURL=positive-safe-int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,iBAAiB,qCAAK,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,eAAe,IAAI,2BAA2B,EACpD,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAgC1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.mjs","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,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;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;AAQG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;;;;;;;;;;;;;;;AAkBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-safe-int.mjs","sources":["../../../src/number/branded-types/positive-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,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;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;AAQG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;;;;;;;;;;;;;;;AAkBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/positive-uint16.d.mts

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;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":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;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/positive-uint16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-uint16.mjs","sources":["../../../src/number/branded-types/positive-uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,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,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;;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":"positive-uint16.mjs","sources":["../../../src/number/branded-types/positive-uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,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,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;;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/positive-uint32.d.mts

@@ -1,3 +1,5 @@
+import { type PositiveUint32 as TtfImported_PositiveUint32 } from 'ts-type-forge';
+export type PositiveUint32 = TtfImported_PositiveUint32;
 /**
  * Checks if a number is a PositiveUint32 (32-bit positive unsigned integer in
  * the range [1, 2^32)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a PositiveUint32, `false` otherwise.
  */
-export declare const isPositiveUint32: (a: number) => a is PositiveUint32;
+export declare const isPositiveUint32: (a: number) => a is TtfImported_PositiveUint32;
 /**
  * Casts a number to a PositiveUint32 type.
  *
@@ -15,6 +17,8 @@ export declare const isPositiveUint32: (a: number) => a is PositiveUint32;
  */
 export declare const asPositiveUint32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "!=0": true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
@@ -22,8 +26,6 @@ export declare const asPositiveUint32: <N extends number>(x: N) => number & {
     readonly ">= -2^31": true;
     readonly ">=0": 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 PositiveUint32: {
      * @returns `true` if the value is a 32-bit positive unsigned integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is PositiveUint32;
+    readonly is: (a: number) => a is TtfImported_PositiveUint32;
     /**
      * The minimum value for a 32-bit positive unsigned integer.
      *
@@ -65,7 +67,7 @@ export declare const PositiveUint32: {
      * @param b The second PositiveUint32.
      * @returns The minimum value as a PositiveUint32.
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>[]) => TtfImported_PositiveUint32;
     /**
      * Returns the larger of two PositiveUint32 values.
      *
@@ -73,20 +75,20 @@ export declare const PositiveUint32: {
      * @param b The second PositiveUint32.
      * @returns The maximum value as a PositiveUint32.
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>[]) => TtfImported_PositiveUint32;
     /**
      * Clamps a number to the PositiveUint32 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 4294967295] as a PositiveUint32.
      */
-    readonly clamp: (x: number) => PositiveUint32;
+    readonly clamp: (x: number) => TtfImported_PositiveUint32;
     /**
      * Generates a random PositiveUint32 value within the valid range.
      *
      * @returns A random PositiveUint32 between 1 and 4294967295.
      */
-    readonly random: (min?: WithSmallInt<PositiveUint32, 40> | undefined, max?: WithSmallInt<PositiveUint32, 40> | undefined) => PositiveUint32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32> | undefined) => TtfImported_PositiveUint32;
     /**
      * Raises a PositiveUint32 to the power of another PositiveUint32.
      *
@@ -94,7 +96,7 @@ export declare const PositiveUint32: {
      * @param b The exponent PositiveUint32.
      * @returns `a ** b` clamped to [1, 4294967295] as a PositiveUint32.
      */
-    readonly pow: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>) => TtfImported_PositiveUint32;
     /**
      * Adds two PositiveUint32 values.
      *
@@ -102,7 +104,7 @@ export declare const PositiveUint32: {
      * @param b The second PositiveUint32.
      * @returns `a + b` clamped to [1, 4294967295] as a PositiveUint32.
      */
-    readonly add: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>) => TtfImported_PositiveUint32;
     /**
      * Subtracts one PositiveUint32 from another.
      *
@@ -111,7 +113,7 @@ export declare const PositiveUint32: {
      * @returns `a - b` clamped to [1, 4294967295] as a PositiveUint32 (minimum
      *   1).
      */
-    readonly sub: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>) => TtfImported_PositiveUint32;
     /**
      * Multiplies two PositiveUint32 values.
      *
@@ -119,7 +121,7 @@ export declare const PositiveUint32: {
      * @param b The second PositiveUint32.
      * @returns `a * b` clamped to [1, 4294967295] as a PositiveUint32.
      */
-    readonly mul: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveUint32>) => TtfImported_PositiveUint32;
     /**
      * Divides one PositiveUint32 by another using floor division.
      *
@@ -127,8 +129,10 @@ export declare const PositiveUint32: {
      * @param b The divisor PositiveUint32.
      * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a PositiveUint32.
      */
-    readonly div: (x: WithSmallInt<PositiveUint32, 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_PositiveUint32>, 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;
@@ -136,11 +140,9 @@ export declare const PositiveUint32: {
         readonly ">= -2^31": true;
         readonly ">=0": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => PositiveUint32;
+    }>>) => TtfImported_PositiveUint32;
 };
 //# sourceMappingURL=positive-uint32.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;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":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;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/positive-uint32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-uint32.mjs","sources":["../../../src/number/branded-types/positive-uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,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,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;;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":"positive-uint32.mjs","sources":["../../../src/number/branded-types/positive-uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,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,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;;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/safe-int.d.mts

@@ -1,4 +1,6 @@
+import { type SafeUint, type SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type SafeInt = TtfImported_SafeInt;
 /**
  * Type guard that checks if a value is a safe integer.
  *
@@ -18,7 +20,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value - The value to check
  * @returns `true` if the value is a safe integer, `false` otherwise
  */
-export declare const isSafeInt: (a: number) => a is SafeInt;
+export declare const isSafeInt: (a: number) => a is TtfImported_SafeInt;
 /**
  * Casts a number to a SafeInt branded type.
  *
@@ -82,13 +84,13 @@ export declare const SafeInt: {
      * @returns `true` if the value is a safe integer, `false` otherwise
      * @see {@link isSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is SafeInt;
+    readonly is: (a: number) => a is TtfImported_SafeInt;
     /**
      * The minimum safe integer value (-(2^53 - 1)).
      *
      * @readonly
      */
-    readonly MIN_VALUE: SafeInt;
+    readonly MIN_VALUE: TtfImported_SafeInt;
     /**
      * The maximum safe integer value (2^53 - 1).
      *
@@ -116,7 +118,7 @@ export declare const SafeInt: {
      * @param a - The safe integer value
      * @returns The absolute value as a SafeInt, clamped if necessary
      */
-    readonly abs: (x: WithSmallInt<SafeInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<SafeInt>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_SafeInt>;
     /**
      * Returns the minimum value from a list of safe integers.
      *
@@ -131,7 +133,7 @@ export declare const SafeInt: {
      * @param values - The safe integers to compare (at least one required)
      * @returns The smallest value as a SafeInt
      */
-    readonly min: (...values: readonly WithSmallInt<SafeInt, 40>[]) => SafeInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>[]) => TtfImported_SafeInt;
     /**
      * Returns the maximum value from a list of safe integers.
      *
@@ -146,7 +148,7 @@ export declare const SafeInt: {
      * @param values - The safe integers to compare (at least one required)
      * @returns The largest value as a SafeInt
      */
-    readonly max: (...values: readonly WithSmallInt<SafeInt, 40>[]) => SafeInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>[]) => TtfImported_SafeInt;
     /**
      * Clamps a number to the safe integer range.
      *
@@ -170,7 +172,7 @@ export declare const SafeInt: {
      * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] as a
      *   SafeInt.
      */
-    readonly clamp: (x: number) => SafeInt;
+    readonly clamp: (x: number) => TtfImported_SafeInt;
     /**
      * Generates a random safe integer within the specified range (inclusive).
      *
@@ -195,7 +197,7 @@ export declare const SafeInt: {
      * @param max - The maximum value (inclusive)
      * @returns A random SafeInt in the range [min, max]
      */
-    readonly random: (min?: WithSmallInt<SafeInt, 40> | undefined, max?: WithSmallInt<SafeInt, 40> | undefined) => SafeInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt> | undefined) => TtfImported_SafeInt;
     /**
      * Raises a SafeInt to the power of another SafeInt.
      *
@@ -217,7 +219,7 @@ export declare const SafeInt: {
      * @param b The exponent SafeInt.
      * @returns `a ** b` clamped to safe integer range as a SafeInt.
      */
-    readonly pow: (x: WithSmallInt<SafeInt, 40>, y: WithSmallInt<SafeInt, 40>) => SafeInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>) => TtfImported_SafeInt;
     /**
      * Adds two SafeInt values.
      *
@@ -235,7 +237,7 @@ export declare const SafeInt: {
      * @param b The second SafeInt.
      * @returns `a + b` clamped to safe integer range as a SafeInt.
      */
-    readonly add: (x: WithSmallInt<SafeInt, 40>, y: WithSmallInt<SafeInt, 40>) => SafeInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>) => TtfImported_SafeInt;
     /**
      * Subtracts one SafeInt from another.
      *
@@ -253,7 +255,7 @@ export declare const SafeInt: {
      * @param b The subtrahend SafeInt.
      * @returns `a - b` clamped to safe integer range as a SafeInt.
      */
-    readonly sub: (x: WithSmallInt<SafeInt, 40>, y: WithSmallInt<SafeInt, 40>) => SafeInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>) => TtfImported_SafeInt;
     /**
      * Multiplies two SafeInt values.
      *
@@ -271,7 +273,7 @@ export declare const SafeInt: {
      * @param b The second SafeInt.
      * @returns `a * b` clamped to safe integer range as a SafeInt.
      */
-    readonly mul: (x: WithSmallInt<SafeInt, 40>, y: WithSmallInt<SafeInt, 40>) => SafeInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeInt>) => TtfImported_SafeInt;
     /**
      * Divides one SafeInt by another using floor division.
      *
@@ -292,14 +294,14 @@ export declare const SafeInt: {
      * @param b - The divisor (must be non-zero)
      * @returns The integer quotient as a SafeInt
      */
-    readonly div: (x: WithSmallInt<SafeInt, 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_SafeInt>, 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 SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => SafeInt;
+    }>>) => TtfImported_SafeInt;
 };
 //# sourceMappingURL=safe-int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAkCnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,6BAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;;;;;;;MAAW,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,OAAO,IAAI,mBAAmB,EACpC,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,OAAO,GAAG,mBAAmB,CAAC;AAkC1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,yCAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;;;;;;;MAAW,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.mjs","sources":["../../../src/number/branded-types/safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,gBAAgB;AAE1C,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;;IAEnC,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,OAAO,GAAG;AACrB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;AAsBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"safe-int.mjs","sources":["../../../src/number/branded-types/safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAWA,MAAM,iBAAiB,GAAG,gBAAgB;AAE1C,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;;IAEnC,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,OAAO,GAAG;AACrB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;AAsBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;;;;;"}