ts-data-forge 6.9.2 → 6.9.4

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAqExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,0CAAK,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBAnHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAmHC;;;;;OAKG;uBA/GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiH3D;;;;;OAKG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAiHC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,IAAI,gCAAgC,EAE9D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAqExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBAnHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAmHC;;;;;OAKG;uBA/GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiH3D;;;;;OAKG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAiHC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.mjs","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;IACA,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAcH;;;;;AAKG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;AAQG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-finite-number.mjs","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAYA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;IACA,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAcH;;;;;AAKG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;AAQG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
+export type PositiveInt = TtfImported_PositiveInt;
 /**
  * Type guard that checks if a value is a positive integer.
  *
@@ -17,7 +19,7 @@
  * @param value - The value to check
  * @returns `true` if the value is a positive integer, `false` otherwise
  */
-export declare const isPositiveInt: (a: number) => a is PositiveInt;
+export declare const isPositiveInt: (a: number) => a is TtfImported_PositiveInt;
 /**
  * Casts a number to a PositiveInt branded type.
  *
@@ -41,14 +43,14 @@ export declare const isPositiveInt: (a: number) => a is PositiveInt;
  */
 export declare const asPositiveInt: <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<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -86,7 +88,7 @@ export declare const PositiveInt: {
      * @returns `true` if the value is a positive integer, `false` otherwise
      * @see {@link isPositiveInt} for usage examples
      */
-    readonly is: (a: number) => a is PositiveInt;
+    readonly is: (a: number) => a is TtfImported_PositiveInt;
     /**
      * The minimum value for a PositiveInt.
      *
@@ -114,7 +116,7 @@ export declare const PositiveInt: {
      * @param values - The positive integers to compare (at least one required)
      * @returns The smallest value as a PositiveInt
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveInt, 40>[]) => PositiveInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>[]) => TtfImported_PositiveInt;
     /**
      * Returns the maximum value from a list of positive integers.
      *
@@ -133,7 +135,7 @@ export declare const PositiveInt: {
      * @param values - The positive integers to compare (at least one required)
      * @returns The largest value as a PositiveInt
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveInt, 40>[]) => PositiveInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>[]) => TtfImported_PositiveInt;
     /**
      * Clamps a number to the positive integer range.
      *
@@ -155,7 +157,7 @@ export declare const PositiveInt: {
      * @param value - The number to clamp
      * @returns The value clamped to >= 1 as a PositiveInt
      */
-    readonly clamp: (x: number) => PositiveInt;
+    readonly clamp: (x: number) => TtfImported_PositiveInt;
     /**
      * Generates a random positive integer within the specified range (inclusive).
      *
@@ -180,7 +182,7 @@ export declare const PositiveInt: {
      * @param max - The maximum value (inclusive, must be >= min)
      * @returns A random PositiveInt in the range [min, max]
      */
-    readonly random: (min?: WithSmallInt<PositiveInt, 40> | undefined, max?: WithSmallInt<PositiveInt, 40> | undefined) => PositiveInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt> | undefined) => TtfImported_PositiveInt;
     /**
      * Raises a positive integer to a power, ensuring the result is never less
      * than 1.
@@ -201,7 +203,7 @@ export declare const PositiveInt: {
      * @param b - The exponent positive integer
      * @returns `a ** b` as a PositiveInt, but never less than 1
      */
-    readonly pow: (x: WithSmallInt<PositiveInt, 40>, y: WithSmallInt<PositiveInt, 40>) => PositiveInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>) => TtfImported_PositiveInt;
     /**
      * Adds two positive integers, ensuring the result is never less than 1.
      *
@@ -217,7 +219,7 @@ export declare const PositiveInt: {
      * @param b - Second positive integer
      * @returns `a + b` as a PositiveInt, but never less than 1
      */
-    readonly add: (x: WithSmallInt<PositiveInt, 40>, y: WithSmallInt<PositiveInt, 40>) => PositiveInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>) => TtfImported_PositiveInt;
     /**
      * Subtracts two positive integers, clamping the result to remain positive.
      *
@@ -236,7 +238,7 @@ export declare const PositiveInt: {
      * @param b - The subtrahend (positive integer)
      * @returns `max(1, a - b)` as a PositiveInt
      */
-    readonly sub: (x: WithSmallInt<PositiveInt, 40>, y: WithSmallInt<PositiveInt, 40>) => PositiveInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>) => TtfImported_PositiveInt;
     /**
      * Multiplies two positive integers, ensuring the result is never less than 1.
      *
@@ -252,7 +254,7 @@ export declare const PositiveInt: {
      * @param b - Second positive integer
      * @returns `a * b` as a PositiveInt, but never less than 1
      */
-    readonly mul: (x: WithSmallInt<PositiveInt, 40>, y: WithSmallInt<PositiveInt, 40>) => PositiveInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt>) => TtfImported_PositiveInt;
     /**
      * Divides two positive integers using floor division, clamping to remain
      * positive.
@@ -277,18 +279,18 @@ export declare const PositiveInt: {
      * @param b - The divisor (positive integer, guaranteed non-zero)
      * @returns `max(1, ⌊a / b⌋)` as a PositiveInt
      */
-    readonly div: (x: WithSmallInt<PositiveInt, 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_PositiveInt>, 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;
-    }>>) => PositiveInt;
+    }>>) => TtfImported_PositiveInt;
 };
 //# sourceMappingURL=positive-int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,iCAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,IAAI,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAI5E,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AA8BlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,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;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;AAeG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,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;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;AAeG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
+export type PositiveInt16 = TtfImported_PositiveInt16;
 /**
  * Checks if a number is a PositiveInt16 (16-bit positive signed integer in the
  * range [1, 2^15)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a PositiveInt16, `false` otherwise.
  */
-export declare const isPositiveInt16: (a: number) => a is PositiveInt16;
+export declare const isPositiveInt16: (a: number) => a is TtfImported_PositiveInt16;
 /**
  * Casts a number to a PositiveInt16 type.
  *
@@ -15,6 +17,8 @@ export declare const isPositiveInt16: (a: number) => a is PositiveInt16;
  */
 export declare const asPositiveInt16: <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;
@@ -25,8 +29,6 @@ export declare const asPositiveInt16: <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;
@@ -48,7 +50,7 @@ export declare const PositiveInt16: {
      * @returns `true` if the value is a 16-bit positive integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is PositiveInt16;
+    readonly is: (a: number) => a is TtfImported_PositiveInt16;
     /**
      * The minimum value for a 16-bit positive integer.
      *
@@ -68,7 +70,7 @@ export declare const PositiveInt16: {
      * @param b The second PositiveInt16.
      * @returns The minimum value as a PositiveInt16.
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveInt16, 40>[]) => PositiveInt16;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>[]) => TtfImported_PositiveInt16;
     /**
      * Returns the larger of two PositiveInt16 values.
      *
@@ -76,20 +78,20 @@ export declare const PositiveInt16: {
      * @param b The second PositiveInt16.
      * @returns The maximum value as a PositiveInt16.
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveInt16, 40>[]) => PositiveInt16;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>[]) => TtfImported_PositiveInt16;
     /**
      * Clamps a number to the PositiveInt16 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly clamp: (x: number) => PositiveInt16;
+    readonly clamp: (x: number) => TtfImported_PositiveInt16;
     /**
      * Generates a random PositiveInt16 value within the valid range.
      *
      * @returns A random PositiveInt16 between 1 and 32767.
      */
-    readonly random: (min?: WithSmallInt<PositiveInt16, 40> | undefined, max?: WithSmallInt<PositiveInt16, 40> | undefined) => PositiveInt16;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16> | undefined) => TtfImported_PositiveInt16;
     /**
      * Raises a PositiveInt16 to the power of another PositiveInt16.
      *
@@ -97,7 +99,7 @@ export declare const PositiveInt16: {
      * @param b The exponent PositiveInt16.
      * @returns `a ** b` clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly pow: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>) => TtfImported_PositiveInt16;
     /**
      * Adds two PositiveInt16 values.
      *
@@ -105,7 +107,7 @@ export declare const PositiveInt16: {
      * @param b The second PositiveInt16.
      * @returns `a + b` clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly add: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>) => TtfImported_PositiveInt16;
     /**
      * Subtracts one PositiveInt16 from another.
      *
@@ -113,7 +115,7 @@ export declare const PositiveInt16: {
      * @param b The subtrahend PositiveInt16.
      * @returns `a - b` clamped to [1, 32767] as a PositiveInt16 (minimum 1).
      */
-    readonly sub: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>) => TtfImported_PositiveInt16;
     /**
      * Multiplies two PositiveInt16 values.
      *
@@ -121,7 +123,7 @@ export declare const PositiveInt16: {
      * @param b The second PositiveInt16.
      * @returns `a * b` clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly mul: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>) => TtfImported_PositiveInt16;
     /**
      * Divides one PositiveInt16 by another using floor division.
      *
@@ -129,8 +131,10 @@ export declare const PositiveInt16: {
      * @param b The divisor PositiveInt16.
      * @returns `⌊a / b⌋` clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly div: (x: WithSmallInt<PositiveInt16, 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_PositiveInt16>, 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;
@@ -141,11 +145,9 @@ export declare const PositiveInt16: {
         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;
-    }>>) => PositiveInt16;
+    }>>) => TtfImported_PositiveInt16;
 };
 //# sourceMappingURL=positive-int16.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mCAAK,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;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-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;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-int16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-int16.mjs","sources":["../../../src/number/branded-types/positive-int16.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,eAAe,GAAG;AAE/B;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;AAQG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;;;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-int16.mjs","sources":["../../../src/number/branded-types/positive-int16.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,eAAe,GAAG;AAE/B;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;AAQG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;;;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-int32.d.mts

@@ -1,3 +1,5 @@
+import { type PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
+export type PositiveInt32 = TtfImported_PositiveInt32;
 /**
  * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the
  * range [1, 2^31)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a PositiveInt32, `false` otherwise.
  */
-export declare const isPositiveInt32: (a: number) => a is PositiveInt32;
+export declare const isPositiveInt32: (a: number) => a is TtfImported_PositiveInt32;
 /**
  * Casts a number to a PositiveInt32 type.
  *
@@ -15,6 +17,8 @@ export declare const isPositiveInt32: (a: number) => a is PositiveInt32;
  */
 export declare const asPositiveInt32: <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;
@@ -23,8 +27,6 @@ export declare const asPositiveInt32: <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;
@@ -46,7 +48,7 @@ export declare const PositiveInt32: {
      * @returns `true` if the value is a 32-bit positive integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is PositiveInt32;
+    readonly is: (a: number) => a is TtfImported_PositiveInt32;
     /**
      * The minimum value for a 32-bit positive integer.
      *
@@ -66,7 +68,7 @@ export declare const PositiveInt32: {
      * @param b The second PositiveInt32.
      * @returns The minimum value as a PositiveInt32.
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveInt32, 40>[]) => PositiveInt32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>[]) => TtfImported_PositiveInt32;
     /**
      * Returns the larger of two PositiveInt32 values.
      *
@@ -74,20 +76,20 @@ export declare const PositiveInt32: {
      * @param b The second PositiveInt32.
      * @returns The maximum value as a PositiveInt32.
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveInt32, 40>[]) => PositiveInt32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>[]) => TtfImported_PositiveInt32;
     /**
      * Clamps a number to the PositiveInt32 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 2147483647] as a PositiveInt32.
      */
-    readonly clamp: (x: number) => PositiveInt32;
+    readonly clamp: (x: number) => TtfImported_PositiveInt32;
     /**
      * Generates a random PositiveInt32 value within the valid range.
      *
      * @returns A random PositiveInt32 between 1 and 2147483647.
      */
-    readonly random: (min?: WithSmallInt<PositiveInt32, 40> | undefined, max?: WithSmallInt<PositiveInt32, 40> | undefined) => PositiveInt32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32> | undefined) => TtfImported_PositiveInt32;
     /**
      * Raises a PositiveInt32 to the power of another PositiveInt32.
      *
@@ -95,7 +97,7 @@ export declare const PositiveInt32: {
      * @param b The exponent PositiveInt32.
      * @returns `a ** b` clamped to [1, 2147483647] as a PositiveInt32.
      */
-    readonly pow: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>) => TtfImported_PositiveInt32;
     /**
      * Adds two PositiveInt32 values.
      *
@@ -103,7 +105,7 @@ export declare const PositiveInt32: {
      * @param b The second PositiveInt32.
      * @returns `a + b` clamped to [1, 2147483647] as a PositiveInt32.
      */
-    readonly add: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>) => TtfImported_PositiveInt32;
     /**
      * Subtracts one PositiveInt32 from another.
      *
@@ -111,7 +113,7 @@ export declare const PositiveInt32: {
      * @param b The subtrahend PositiveInt32.
      * @returns `a - b` clamped to [1, 2147483647] as a PositiveInt32 (minimum 1).
      */
-    readonly sub: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>) => TtfImported_PositiveInt32;
     /**
      * Multiplies two PositiveInt32 values.
      *
@@ -119,7 +121,7 @@ export declare const PositiveInt32: {
      * @param b The second PositiveInt32.
      * @returns `a * b` clamped to [1, 2147483647] as a PositiveInt32.
      */
-    readonly mul: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt32>) => TtfImported_PositiveInt32;
     /**
      * Divides one PositiveInt32 by another using floor division.
      *
@@ -127,8 +129,10 @@ export declare const PositiveInt32: {
      * @param b The divisor PositiveInt32.
      * @returns `⌊a / b⌋` clamped to [1, 2147483647] as a PositiveInt32.
      */
-    readonly div: (x: WithSmallInt<PositiveInt32, 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_PositiveInt32>, 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 PositiveInt32: {
         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;
-    }>>) => PositiveInt32;
+    }>>) => TtfImported_PositiveInt32;
 };
 //# sourceMappingURL=positive-int32.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mCAAK,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;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-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;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-int32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.mjs","sources":["../../../src/number/branded-types/positive-int32.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,eAAe,GAAG;AAE/B;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;AAQG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;;;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-int32.mjs","sources":["../../../src/number/branded-types/positive-int32.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,eAAe,GAAG;AAE/B;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;AAQG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;;;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;;;;;"}