ts-data-forge 6.9.1 → 6.9.3

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;;;;;"}

package/dist/number/branded-types/safe-uint.d.mts

@@ -1,10 +1,12 @@
+import { type SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
+export type SafeUint = TtfImported_SafeUint;
 /**
  * Checks if a number is a SafeUint.
  *
  * @param value The value to check.
  * @returns `true` if the value is a SafeUint, `false` otherwise.
  */
-export declare const isSafeUint: (a: number) => a is SafeUint;
+export declare const isSafeUint: (a: number) => a is TtfImported_SafeUint;
 /**
  * Casts a number to a SafeUint type.
  *
@@ -14,13 +16,13 @@ export declare const isSafeUint: (a: number) => a is SafeUint;
  */
 export declare const asSafeUint: <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;
     readonly ">= -2^31": true;
     readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -42,7 +44,7 @@ export declare const SafeUint: {
      * @returns `true` if the value is a non-negative safe integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is SafeUint;
+    readonly is: (a: number) => a is TtfImported_SafeUint;
     /**
      * The minimum value for a safe unsigned integer.
      *
@@ -54,7 +56,7 @@ export declare const SafeUint: {
      *
      * @readonly
      */
-    readonly MAX_VALUE: SafeUint;
+    readonly MAX_VALUE: TtfImported_SafeUint;
     /**
      * Returns the smaller of two SafeUint values.
      *
@@ -62,7 +64,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns The minimum value as a SafeUint.
      */
-    readonly min: (...values: readonly WithSmallInt<SafeUint, 40>[]) => SafeUint;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>[]) => TtfImported_SafeUint;
     /**
      * Returns the larger of two SafeUint values.
      *
@@ -70,20 +72,20 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns The maximum value as a SafeUint.
      */
-    readonly max: (...values: readonly WithSmallInt<SafeUint, 40>[]) => SafeUint;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>[]) => TtfImported_SafeUint;
     /**
      * Clamps a number to the safe unsigned integer range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly clamp: (x: number) => SafeUint;
+    readonly clamp: (x: number) => TtfImported_SafeUint;
     /**
      * Generates a random SafeUint value within the valid range.
      *
      * @returns A random SafeUint between 0 and MAX_SAFE_INTEGER.
      */
-    readonly random: (min?: WithSmallInt<SafeUint, 40> | undefined, max?: WithSmallInt<SafeUint, 40> | undefined) => SafeUint;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint> | undefined) => TtfImported_SafeUint;
     /**
      * Raises a SafeUint to the power of another SafeUint.
      *
@@ -91,7 +93,7 @@ export declare const SafeUint: {
      * @param b The exponent SafeUint.
      * @returns `a ** b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly pow: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Adds two SafeUint values.
      *
@@ -99,7 +101,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns `a + b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly add: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Subtracts one SafeUint from another.
      *
@@ -108,7 +110,7 @@ export declare const SafeUint: {
      * @returns `a - b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint (minimum
      *   0).
      */
-    readonly sub: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Multiplies two SafeUint values.
      *
@@ -116,7 +118,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns `a * b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly mul: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Divides one SafeUint by another using floor division.
      *
@@ -124,19 +126,19 @@ export declare const SafeUint: {
      * @param b The divisor SafeUint.
      * @returns `⌊a / b⌋` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly div: (x: WithSmallInt<SafeUint, 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_SafeUint>, 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;
-    }>>) => SafeUint;
+    }>>) => TtfImported_SafeUint;
 };
 //# sourceMappingURL=safe-uint.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"safe-uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.mts"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,8BAAK,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;MAAW,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;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":"safe-uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,IAAI,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAItE,MAAM,MAAM,QAAQ,GAAG,oBAAoB,CAAC;AAgC5C;;;;;GAKG;AACH,eAAO,MAAM,UAAU,0CAAK,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;MAAW,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;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/safe-uint.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"safe-uint.mjs","sources":["../../../src/number/branded-types/safe-uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,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;;;;;AAKG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;AAQG;AACI,MAAM,QAAQ,GAAG;AACtB;;;;;;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":"safe-uint.mjs","sources":["../../../src/number/branded-types/safe-uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,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;;;;;AAKG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;AAQG;AACI,MAAM,QAAQ,GAAG;AACtB;;;;;;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/uint.d.mts

@@ -1,3 +1,5 @@
+import { type Uint as TtfImported_Uint } from 'ts-type-forge';
+export type Uint = TtfImported_Uint;
 /**
  * Checks if a number is a Uint.
  *
@@ -14,7 +16,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a Uint, `false` otherwise.
  */
-export declare const isUint: (a: number) => a is NonNegativeInt;
+export declare const isUint: (a: number) => a is import("ts-type-forge").NonNegativeInt;
 /**
  * Casts a number to a Uint type.
  *
@@ -34,13 +36,13 @@ export declare const isUint: (a: number) => a is NonNegativeInt;
  */
 export declare const asUint: <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;
     readonly ">= -2^31": true;
     readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -69,7 +71,7 @@ export declare const Uint: {
      * @returns `true` if the value is a non-negative integer, `false` otherwise.
      * @see {@link isUint} for usage examples
      */
-    readonly is: (a: number) => a is NonNegativeInt;
+    readonly is: (a: number) => a is import("ts-type-forge").NonNegativeInt;
     /**
      * The minimum value for an unsigned integer.
      *
@@ -91,7 +93,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns The minimum value as a Uint.
      */
-    readonly min: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>[]) => import("ts-type-forge").NonNegativeInt;
     /**
      * Returns the larger of two Uint values.
      *
@@ -107,7 +109,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns The maximum value as a Uint.
      */
-    readonly max: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>[]) => import("ts-type-forge").NonNegativeInt;
     /**
      * Clamps a number to the Uint range (non-negative).
      *
@@ -126,7 +128,7 @@ export declare const Uint: {
      * @param value The number to clamp.
      * @returns The value clamped to [0, +∞) as a Uint.
      */
-    readonly clamp: (x: number) => NonNegativeInt;
+    readonly clamp: (x: number) => import("ts-type-forge").NonNegativeInt;
     /**
      * Generates a random Uint value.
      *
@@ -146,7 +148,7 @@ export declare const Uint: {
      *
      * @returns A random non-negative integer as a Uint.
      */
-    readonly random: (min?: WithSmallInt<NonNegativeInt, 40> | undefined, max?: WithSmallInt<NonNegativeInt, 40> | undefined) => NonNegativeInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt> | undefined, max?: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt> | undefined) => import("ts-type-forge").NonNegativeInt;
     /**
      * Raises a Uint to the power of another Uint.
      *
@@ -166,7 +168,7 @@ export declare const Uint: {
      * @param b The exponent Uint.
      * @returns `a ** b` clamped to [0, +∞) as a Uint.
      */
-    readonly pow: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Adds two Uint values.
      *
@@ -182,7 +184,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns `a + b` clamped to [0, +∞) as a Uint.
      */
-    readonly add: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Subtracts one Uint from another.
      *
@@ -198,7 +200,7 @@ export declare const Uint: {
      * @param b The subtrahend Uint.
      * @returns `a - b` clamped to [0, +∞) as a Uint (minimum 0).
      */
-    readonly sub: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Multiplies two Uint values.
      *
@@ -214,7 +216,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns `a * b` clamped to [0, +∞) as a Uint.
      */
-    readonly mul: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Divides one Uint by another using floor division.
      *
@@ -230,18 +232,18 @@ export declare const Uint: {
      * @param b The divisor Uint.
      * @returns `⌊a / b⌋` clamped to [0, +∞) as a Uint.
      */
-    readonly div: (x: WithSmallInt<NonNegativeInt, 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<import("ts-type-forge").NonNegativeInt>, 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<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => NonNegativeInt;
+    }>>) => import("ts-type-forge").NonNegativeInt;
 };
 //# sourceMappingURL=uint.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,oCAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAI9D,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AA8BpC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,4DAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,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,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;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":"uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIlE,MAAM,MAAM,MAAM,GAAG,kBAAkB,CAAC;AA+BxC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,wCAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;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/uint16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;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":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;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;;;;;"}