ts-data-forge 6.9.2 → 6.9.3

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

@@ -1,4 +1,6 @@
+import { type NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonZeroInt32 = TtfImported_NonZeroInt32;
 /**
  * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the
  * range [-2^31, 2^31) excluding 0).
@@ -6,7 +8,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt32, `false` otherwise.
  */
-export declare const isNonZeroInt32: (a: number) => a is NonZeroInt32;
+export declare const isNonZeroInt32: (a: number) => a is TtfImported_NonZeroInt32;
 /**
  * Casts a number to a NonZeroInt32 type.
  *
@@ -16,13 +18,13 @@ export declare const isNonZeroInt32: (a: number) => a is NonZeroInt32;
  */
 export declare const asNonZeroInt32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "!=0": true;
     readonly "> -2^32": true;
     readonly ">= -2^31": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -44,7 +46,7 @@ export declare const NonZeroInt32: {
      * @returns `true` if the value is a 32-bit non-zero signed integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is NonZeroInt32;
+    readonly is: (a: number) => a is TtfImported_NonZeroInt32;
     /**
      * The minimum value for a 32-bit non-zero signed integer.
      *
@@ -63,7 +65,7 @@ export declare const NonZeroInt32: {
      * @param a The NonZeroInt32 value.
      * @returns The absolute value as a NonZeroInt32, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<NonZeroInt32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt32>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_NonZeroInt32>;
     /**
      * Returns the smaller of two NonZeroInt32 values.
      *
@@ -71,7 +73,7 @@ export declare const NonZeroInt32: {
      * @param b The second NonZeroInt32.
      * @returns The minimum value as a NonZeroInt32.
      */
-    readonly min: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>[]) => TtfImported_NonZeroInt32;
     /**
      * Returns the larger of two NonZeroInt32 values.
      *
@@ -79,7 +81,7 @@ export declare const NonZeroInt32: {
      * @param b The second NonZeroInt32.
      * @returns The maximum value as a NonZeroInt32.
      */
-    readonly max: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>[]) => TtfImported_NonZeroInt32;
     /**
      * Clamps a number to the NonZeroInt32 range (avoiding zero).
      *
@@ -87,14 +89,14 @@ export declare const NonZeroInt32: {
      * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a
      *   NonZeroInt32.
      */
-    readonly clamp: (x: number) => NonZeroInt32;
+    readonly clamp: (x: number) => TtfImported_NonZeroInt32;
     /**
      * Generates a random NonZeroInt32 value within the valid range.
      *
      * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding
      *   0).
      */
-    readonly random: (min?: WithSmallInt<NonZeroInt32, 40> | undefined, max?: WithSmallInt<NonZeroInt32, 40> | undefined) => NonZeroInt32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32> | undefined) => TtfImported_NonZeroInt32;
     /**
      * Raises a NonZeroInt32 to the power of another NonZeroInt32.
      *
@@ -102,7 +104,7 @@ export declare const NonZeroInt32: {
      * @param b The exponent NonZeroInt32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
      */
-    readonly pow: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>) => TtfImported_NonZeroInt32;
     /**
      * Adds two NonZeroInt32 values.
      *
@@ -110,7 +112,7 @@ export declare const NonZeroInt32: {
      * @param b The second NonZeroInt32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
      */
-    readonly add: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>) => TtfImported_NonZeroInt32;
     /**
      * Subtracts one NonZeroInt32 from another.
      *
@@ -118,7 +120,7 @@ export declare const NonZeroInt32: {
      * @param b The subtrahend NonZeroInt32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
      */
-    readonly sub: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>) => TtfImported_NonZeroInt32;
     /**
      * Multiplies two NonZeroInt32 values.
      *
@@ -126,7 +128,7 @@ export declare const NonZeroInt32: {
      * @param b The second NonZeroInt32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
      */
-    readonly mul: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroInt32>) => TtfImported_NonZeroInt32;
     /**
      * Divides one NonZeroInt32 by another using floor division.
      *
@@ -134,18 +136,18 @@ export declare const NonZeroInt32: {
      * @param b The divisor NonZeroInt32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
      */
-    readonly div: (x: WithSmallInt<NonZeroInt32, 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_NonZeroInt32>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -40 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -20 | -30 | -12 | -13 | -14 | -15 | -16 | -17 | -18 | -19 | -21 | -22 | -23 | -24 | -25 | -26 | -27 | -28 | -29 | -31 | -33 | -34 | -35 | -36 | -37 | -38 | -39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^32": true;
         readonly ">= -2^31": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => NonZeroInt32;
+    }>>) => TtfImported_NonZeroInt32;
 };
 //# sourceMappingURL=non-zero-int32.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAE9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAiCpD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,8CAAK,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.mjs","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;AAQG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-int32.mjs","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;AAQG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,6 @@
+import { type SafeInt, type SafeUint, type NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
 /**
  * Checks if a number is a NonZeroSafeInt (a non-zero safe integer in the range
  * [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] excluding 0).
@@ -6,7 +8,7 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroSafeInt, `false` otherwise.
  */
-export declare const isNonZeroSafeInt: (a: number) => a is NonZeroSafeInt;
+export declare const isNonZeroSafeInt: (a: number) => a is TtfImported_NonZeroSafeInt;
 /**
  * Casts a number to a NonZeroSafeInt type.
  *
@@ -16,9 +18,9 @@ export declare const isNonZeroSafeInt: (a: number) => a is NonZeroSafeInt;
  */
 export declare const asNonZeroSafeInt: <N extends number>(x: N) => 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;
@@ -39,7 +41,7 @@ export declare const NonZeroSafeInt: {
      * @param value The value to check.
      * @returns `true` if the value is a non-zero safe integer, `false` otherwise.
      */
-    readonly is: (a: number) => a is NonZeroSafeInt;
+    readonly is: (a: number) => a is TtfImported_NonZeroSafeInt;
     /**
      * The minimum safe integer value (-(2^53 - 1)).
      *
@@ -58,7 +60,7 @@ export declare const NonZeroSafeInt: {
      * @param a The NonZeroSafeInt value.
      * @returns The absolute value as a NonZeroSafeInt, clamped to safe range.
      */
-    readonly abs: (x: WithSmallInt<NonZeroSafeInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroSafeInt>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_NonZeroSafeInt>;
     /**
      * Returns the smaller of two NonZeroSafeInt values.
      *
@@ -66,7 +68,7 @@ export declare const NonZeroSafeInt: {
      * @param b The second NonZeroSafeInt.
      * @returns The minimum value as a NonZeroSafeInt.
      */
-    readonly min: (...values: readonly WithSmallInt<NonZeroSafeInt, 40>[]) => NonZeroSafeInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>[]) => TtfImported_NonZeroSafeInt;
     /**
      * Returns the larger of two NonZeroSafeInt values.
      *
@@ -74,7 +76,7 @@ export declare const NonZeroSafeInt: {
      * @param b The second NonZeroSafeInt.
      * @returns The maximum value as a NonZeroSafeInt.
      */
-    readonly max: (...values: readonly WithSmallInt<NonZeroSafeInt, 40>[]) => NonZeroSafeInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>[]) => TtfImported_NonZeroSafeInt;
     /**
      * Clamps a number to the non-zero safe integer range.
      *
@@ -82,14 +84,14 @@ export declare const NonZeroSafeInt: {
      * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] \ {0} as
      *   a NonZeroSafeInt.
      */
-    readonly clamp: (x: number) => NonZeroSafeInt;
+    readonly clamp: (x: number) => TtfImported_NonZeroSafeInt;
     /**
      * Generates a random NonZeroSafeInt value within the valid range.
      *
      * @returns A random non-zero safe integer between MIN_SAFE_INTEGER and
      *   MAX_SAFE_INTEGER.
      */
-    readonly random: (min?: WithSmallInt<NonZeroSafeInt, 40> | undefined, max?: WithSmallInt<NonZeroSafeInt, 40> | undefined) => NonZeroSafeInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt> | undefined) => TtfImported_NonZeroSafeInt;
     /**
      * Raises a NonZeroSafeInt to the power of another NonZeroSafeInt.
      *
@@ -98,7 +100,7 @@ export declare const NonZeroSafeInt: {
      * @returns `a ** b` clamped to non-zero safe integer range as a
      *   NonZeroSafeInt.
      */
-    readonly pow: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>) => TtfImported_NonZeroSafeInt;
     /**
      * Adds two NonZeroSafeInt values.
      *
@@ -107,7 +109,7 @@ export declare const NonZeroSafeInt: {
      * @returns `a + b` clamped to non-zero safe integer range as a
      *   NonZeroSafeInt.
      */
-    readonly add: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>) => TtfImported_NonZeroSafeInt;
     /**
      * Subtracts one NonZeroSafeInt from another.
      *
@@ -116,7 +118,7 @@ export declare const NonZeroSafeInt: {
      * @returns `a - b` clamped to non-zero safe integer range as a
      *   NonZeroSafeInt.
      */
-    readonly sub: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>) => TtfImported_NonZeroSafeInt;
     /**
      * Multiplies two NonZeroSafeInt values.
      *
@@ -125,7 +127,7 @@ export declare const NonZeroSafeInt: {
      * @returns `a * b` clamped to non-zero safe integer range as a
      *   NonZeroSafeInt.
      */
-    readonly mul: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>, y: import("ts-type-forge").WithSmallInt<TtfImported_NonZeroSafeInt>) => TtfImported_NonZeroSafeInt;
     /**
      * Divides one NonZeroSafeInt by another using floor division.
      *
@@ -134,14 +136,14 @@ export declare const NonZeroSafeInt: {
      * @returns `⌊a / b⌋` clamped to non-zero safe integer range as a
      *   NonZeroSafeInt.
      */
-    readonly div: (x: WithSmallInt<NonZeroSafeInt, 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_NonZeroSafeInt>, 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;
-    }>>) => NonZeroSafeInt;
+    }>>) => TtfImported_NonZeroSafeInt;
 };
 //# sourceMappingURL=non-zero-safe-int.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAmCnE;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,cAAc,IAAI,0BAA0B,EAClD,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAmCxD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.mjs","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;;IAEb,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-safe-int.mjs","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAYA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;;IAEb,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,oCAAK,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":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAgCtD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,4DAAK,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/non-zero-uint16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint16.mjs","sources":["../../../src/number/branded-types/non-zero-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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,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":"non-zero-uint16.mjs","sources":["../../../src/number/branded-types/non-zero-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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,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/non-zero-uint32.d.mts

@@ -1,3 +1,5 @@
+import { type NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
+export type NonZeroUint32 = TtfImported_NonZeroUint32;
 /**
  * Checks if a number is a NonZeroUint32 (32-bit non-zero 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 NonZeroUint32, `false` otherwise.
  */
-export declare const isNonZeroUint32: (a: number) => a is PositiveUint32;
+export declare const isNonZeroUint32: (a: number) => a is import("ts-type-forge").PositiveUint32;
 /**
  * Casts a number to a NonZeroUint32 type.
  *
@@ -15,6 +17,8 @@ export declare const isNonZeroUint32: (a: number) => a is PositiveUint32;
  */
 export declare const asNonZeroUint32: <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 asNonZeroUint32: <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 NonZeroUint32: {
      * @returns `true` if the value is a 32-bit non-zero unsigned integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is PositiveUint32;
+    readonly is: (a: number) => a is import("ts-type-forge").PositiveUint32;
     /**
      * The minimum value for a 32-bit non-zero unsigned integer.
      *
@@ -65,7 +67,7 @@ export declare const NonZeroUint32: {
      * @param b The second NonZeroUint32.
      * @returns The minimum value as a NonZeroUint32.
      */
-    readonly min: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>[]) => import("ts-type-forge").PositiveUint32;
     /**
      * Returns the larger of two NonZeroUint32 values.
      *
@@ -73,20 +75,20 @@ export declare const NonZeroUint32: {
      * @param b The second NonZeroUint32.
      * @returns The maximum value as a NonZeroUint32.
      */
-    readonly max: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>[]) => import("ts-type-forge").PositiveUint32;
     /**
      * Clamps a number to the NonZeroUint32 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 4294967295] as a NonZeroUint32.
      */
-    readonly clamp: (x: number) => PositiveUint32;
+    readonly clamp: (x: number) => import("ts-type-forge").PositiveUint32;
     /**
      * Generates a random NonZeroUint32 value within the valid range.
      *
      * @returns A random NonZeroUint32 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<import("ts-type-forge").PositiveUint32> | undefined, max?: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32> | undefined) => import("ts-type-forge").PositiveUint32;
     /**
      * Raises a NonZeroUint32 to the power of another NonZeroUint32.
      *
@@ -94,7 +96,7 @@ export declare const NonZeroUint32: {
      * @param b The exponent NonZeroUint32.
      * @returns `a ** b` clamped to [1, 4294967295] as a NonZeroUint32.
      */
-    readonly pow: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>) => import("ts-type-forge").PositiveUint32;
     /**
      * Adds two NonZeroUint32 values.
      *
@@ -102,7 +104,7 @@ export declare const NonZeroUint32: {
      * @param b The second NonZeroUint32.
      * @returns `a + b` clamped to [1, 4294967295] as a NonZeroUint32.
      */
-    readonly add: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>) => import("ts-type-forge").PositiveUint32;
     /**
      * Subtracts one NonZeroUint32 from another.
      *
@@ -110,7 +112,7 @@ export declare const NonZeroUint32: {
      * @param b The subtrahend NonZeroUint32.
      * @returns `a - b` clamped to [1, 4294967295] as a NonZeroUint32 (minimum 1).
      */
-    readonly sub: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>) => import("ts-type-forge").PositiveUint32;
     /**
      * Multiplies two NonZeroUint32 values.
      *
@@ -118,7 +120,7 @@ export declare const NonZeroUint32: {
      * @param b The second NonZeroUint32.
      * @returns `a * b` clamped to [1, 4294967295] as a NonZeroUint32.
      */
-    readonly mul: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").PositiveUint32>) => import("ts-type-forge").PositiveUint32;
     /**
      * Divides one NonZeroUint32 by another using floor division.
      *
@@ -126,8 +128,10 @@ export declare const NonZeroUint32: {
      * @param b The divisor NonZeroUint32.
      * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a NonZeroUint32.
      */
-    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<import("ts-type-forge").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;
@@ -135,11 +139,9 @@ export declare const NonZeroUint32: {
         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;
+    }>>) => import("ts-type-forge").PositiveUint32;
 };
 //# sourceMappingURL=non-zero-uint32.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,oCAAK,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":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAgCtD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,4DAAK,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/non-zero-uint32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.mjs","sources":["../../../src/number/branded-types/non-zero-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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,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":"non-zero-uint32.mjs","sources":["../../../src/number/branded-types/non-zero-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,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,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;;;;;"}