ts-data-forge 1.0.0 → 1.0.2

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

@@ -0,0 +1,160 @@
+/**
+ * Checks if a number is a PositiveUint16 (16-bit positive unsigned integer in the range [1, 2^16)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveUint16, `false` otherwise.
+ */
+export declare const isPositiveUint16: (a: number) => a is PositiveUint16;
+/**
+ * Casts a number to a PositiveUint16 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveUint16 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^16).
+ * @example
+ * ```typescript
+ * const x = asPositiveUint16(1000); // PositiveUint16
+ * const y = asPositiveUint16(65535); // PositiveUint16
+ * // asPositiveUint16(0); // throws TypeError
+ * // asPositiveUint16(-1); // throws TypeError
+ * // asPositiveUint16(65536); // throws TypeError
+ * ```
+ */
+export declare const asPositiveUint16: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    readonly ">=0": true;
+    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;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for 16-bit positive unsigned integers.
+ *
+ * All operations automatically clamp results to the valid PositiveUint16 range [1, 65535].
+ * This ensures that all arithmetic maintains the 16-bit positive unsigned integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveUint16(60000);
+ * const b = asPositiveUint16(10000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveUint16.add(a, b);       // PositiveUint16 (65535 - clamped to MAX_VALUE)
+ * const diff = PositiveUint16.sub(a, b);      // PositiveUint16 (50000)
+ * const reverseDiff = PositiveUint16.sub(b, a); // PositiveUint16 (1 - clamped to MIN_VALUE)
+ * const product = PositiveUint16.mul(a, b);   // PositiveUint16 (65535 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveUint16.clamp(-100);     // PositiveUint16 (1)
+ * const minimum = PositiveUint16.min(a, b);       // PositiveUint16 (10000)
+ * const maximum = PositiveUint16.max(a, b);       // PositiveUint16 (60000)
+ *
+ * // Utility operations
+ * const random = PositiveUint16.random();         // PositiveUint16 (random value in [1, 65535])
+ * const power = PositiveUint16.pow(asPositiveUint16(2), asPositiveUint16(10)); // PositiveUint16 (1024)
+ * ```
+ */
+export declare const PositiveUint16: {
+    /**
+     * Type guard to check if a value is a PositiveUint16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit positive unsigned integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is PositiveUint16;
+    /**
+     * The minimum value for a 16-bit positive unsigned integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 1;
+    /**
+     * The maximum value for a 16-bit positive unsigned integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns The minimum value as a PositiveUint16.
+     */
+    readonly min: (...values: readonly WithSmallInt<PositiveUint16, 40>[]) => PositiveUint16;
+    /**
+     * Returns the larger of two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns The maximum value as a PositiveUint16.
+     */
+    readonly max: (...values: readonly WithSmallInt<PositiveUint16, 40>[]) => PositiveUint16;
+    /**
+     * Clamps a number to the PositiveUint16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 65535] as a PositiveUint16.
+     */
+    readonly clamp: (x: number) => PositiveUint16;
+    /**
+     * Generates a random PositiveUint16 value within the valid range.
+     * @returns A random PositiveUint16 between 1 and 65535.
+     */
+    readonly random: (min: WithSmallInt<PositiveUint16, 40>, max: WithSmallInt<PositiveUint16, 40>) => PositiveUint16;
+    /**
+     * Raises a PositiveUint16 to the power of another PositiveUint16.
+     * @param a The base PositiveUint16.
+     * @param b The exponent PositiveUint16.
+     * @returns `a ** b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    readonly pow: (x: WithSmallInt<PositiveUint16, 40>, y: WithSmallInt<PositiveUint16, 40>) => PositiveUint16;
+    /**
+     * Adds two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns `a + b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    readonly add: (x: WithSmallInt<PositiveUint16, 40>, y: WithSmallInt<PositiveUint16, 40>) => PositiveUint16;
+    /**
+     * Subtracts one PositiveUint16 from another.
+     * @param a The minuend PositiveUint16.
+     * @param b The subtrahend PositiveUint16.
+     * @returns `a - b` clamped to [1, 65535] as a PositiveUint16 (minimum 1).
+     */
+    readonly sub: (x: WithSmallInt<PositiveUint16, 40>, y: WithSmallInt<PositiveUint16, 40>) => PositiveUint16;
+    /**
+     * Multiplies two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns `a * b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    readonly mul: (x: WithSmallInt<PositiveUint16, 40>, y: WithSmallInt<PositiveUint16, 40>) => PositiveUint16;
+    /**
+     * Divides one PositiveUint16 by another using floor division.
+     * @param a The dividend PositiveUint16.
+     * @param b The divisor PositiveUint16.
+     * @returns `⌊a / b⌋` clamped to [1, 65535] as a PositiveUint16.
+     */
+    readonly div: (x: WithSmallInt<PositiveUint16, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly "> -2^16": true;
+        readonly "> -2^32": true;
+        readonly ">= -2^15": true;
+        readonly ">= -2^31": true;
+        readonly ">=0": true;
+        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;
+};
+//# sourceMappingURL=positive-uint16.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc;IACzB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-uint16.mjs

@@ -0,0 +1,139 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a positive integer in [1, 2^16)';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 1,
+    MAX_VALUE: 2 ** 16 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a PositiveUint16 (16-bit positive unsigned integer in the range [1, 2^16)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveUint16, `false` otherwise.
+ */
+const isPositiveUint16 = is;
+/**
+ * Casts a number to a PositiveUint16 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveUint16 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^16).
+ * @example
+ * ```typescript
+ * const x = asPositiveUint16(1000); // PositiveUint16
+ * const y = asPositiveUint16(65535); // PositiveUint16
+ * // asPositiveUint16(0); // throws TypeError
+ * // asPositiveUint16(-1); // throws TypeError
+ * // asPositiveUint16(65536); // throws TypeError
+ * ```
+ */
+const asPositiveUint16 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 16-bit positive unsigned integers.
+ *
+ * All operations automatically clamp results to the valid PositiveUint16 range [1, 65535].
+ * This ensures that all arithmetic maintains the 16-bit positive unsigned integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveUint16(60000);
+ * const b = asPositiveUint16(10000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveUint16.add(a, b);       // PositiveUint16 (65535 - clamped to MAX_VALUE)
+ * const diff = PositiveUint16.sub(a, b);      // PositiveUint16 (50000)
+ * const reverseDiff = PositiveUint16.sub(b, a); // PositiveUint16 (1 - clamped to MIN_VALUE)
+ * const product = PositiveUint16.mul(a, b);   // PositiveUint16 (65535 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveUint16.clamp(-100);     // PositiveUint16 (1)
+ * const minimum = PositiveUint16.min(a, b);       // PositiveUint16 (10000)
+ * const maximum = PositiveUint16.max(a, b);       // PositiveUint16 (60000)
+ *
+ * // Utility operations
+ * const random = PositiveUint16.random();         // PositiveUint16 (random value in [1, 65535])
+ * const power = PositiveUint16.pow(asPositiveUint16(2), asPositiveUint16(10)); // PositiveUint16 (1024)
+ * ```
+ */
+const PositiveUint16 = {
+    /**
+     * Type guard to check if a value is a PositiveUint16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit positive unsigned integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 16-bit positive unsigned integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 16-bit positive unsigned integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns The minimum value as a PositiveUint16.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns The maximum value as a PositiveUint16.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the PositiveUint16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 65535] as a PositiveUint16.
+     */
+    clamp,
+    /**
+     * Generates a random PositiveUint16 value within the valid range.
+     * @returns A random PositiveUint16 between 1 and 65535.
+     */
+    random,
+    /**
+     * Raises a PositiveUint16 to the power of another PositiveUint16.
+     * @param a The base PositiveUint16.
+     * @param b The exponent PositiveUint16.
+     * @returns `a ** b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    pow,
+    /**
+     * Adds two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns `a + b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    add,
+    /**
+     * Subtracts one PositiveUint16 from another.
+     * @param a The minuend PositiveUint16.
+     * @param b The subtrahend PositiveUint16.
+     * @returns `a - b` clamped to [1, 65535] as a PositiveUint16 (minimum 1).
+     */
+    sub,
+    /**
+     * Multiplies two PositiveUint16 values.
+     * @param a The first PositiveUint16.
+     * @param b The second PositiveUint16.
+     * @returns `a * b` clamped to [1, 65535] as a PositiveUint16.
+     */
+    mul,
+    /**
+     * Divides one PositiveUint16 by another using floor division.
+     * @param a The dividend PositiveUint16.
+     * @param b The divisor PositiveUint16.
+     * @returns `⌊a / b⌋` clamped to [1, 65535] as a PositiveUint16.
+     */
+    div,
+};
+
+export { PositiveUint16, asPositiveUint16, isPositiveUint16 };
+//# sourceMappingURL=positive-uint16.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-uint16.mjs","sources":["../../../src/number/branded-types/positive-uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;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;;;;AAIG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;;AAaG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,156 @@
+/**
+ * Checks if a number is a PositiveUint32 (32-bit positive unsigned integer in the range [1, 2^32)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveUint32, `false` otherwise.
+ */
+export declare const isPositiveUint32: (a: number) => a is PositiveUint32;
+/**
+ * Casts a number to a PositiveUint32 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveUint32 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^32).
+ * @example
+ * ```typescript
+ * const x = asPositiveUint32(1000); // PositiveUint32
+ * const y = asPositiveUint32(4294967295); // PositiveUint32
+ * // asPositiveUint32(0); // throws TypeError
+ * // asPositiveUint32(-1); // throws TypeError
+ * // asPositiveUint32(4294967296); // throws TypeError
+ * ```
+ */
+export declare const asPositiveUint32: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    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;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit positive unsigned integers.
+ *
+ * All operations automatically clamp results to the valid PositiveUint32 range [1, 4294967295].
+ * This ensures that all arithmetic maintains the 32-bit positive unsigned integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveUint32(4000000000);
+ * const b = asPositiveUint32(1000000000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveUint32.add(a, b);       // PositiveUint32 (4294967295 - clamped to MAX_VALUE)
+ * const diff = PositiveUint32.sub(a, b);      // PositiveUint32 (3000000000)
+ * const reverseDiff = PositiveUint32.sub(b, a); // PositiveUint32 (1 - clamped to MIN_VALUE)
+ * const product = PositiveUint32.mul(a, b);   // PositiveUint32 (4294967295 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveUint32.clamp(-100);     // PositiveUint32 (1)
+ * const minimum = PositiveUint32.min(a, b);       // PositiveUint32 (1000000000)
+ * const maximum = PositiveUint32.max(a, b);       // PositiveUint32 (4000000000)
+ *
+ * // Utility operations
+ * const random = PositiveUint32.random();         // PositiveUint32 (random value in [1, 4294967295])
+ * const power = PositiveUint32.pow(asPositiveUint32(2), asPositiveUint32(20)); // PositiveUint32 (1048576)
+ * ```
+ */
+export declare const PositiveUint32: {
+    /**
+     * Type guard to check if a value is a PositiveUint32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit positive unsigned integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is PositiveUint32;
+    /**
+     * The minimum value for a 32-bit positive unsigned integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 1;
+    /**
+     * The maximum value for a 32-bit positive unsigned integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns The minimum value as a PositiveUint32.
+     */
+    readonly min: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    /**
+     * Returns the larger of two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns The maximum value as a PositiveUint32.
+     */
+    readonly max: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
+    /**
+     * Clamps a number to the PositiveUint32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    readonly clamp: (x: number) => PositiveUint32;
+    /**
+     * Generates a random PositiveUint32 value within the valid range.
+     * @returns A random PositiveUint32 between 1 and 4294967295.
+     */
+    readonly random: (min: WithSmallInt<PositiveUint32, 40>, max: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    /**
+     * Raises a PositiveUint32 to the power of another PositiveUint32.
+     * @param a The base PositiveUint32.
+     * @param b The exponent PositiveUint32.
+     * @returns `a ** b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    readonly pow: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    /**
+     * Adds two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns `a + b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    readonly add: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    /**
+     * Subtracts one PositiveUint32 from another.
+     * @param a The minuend PositiveUint32.
+     * @param b The subtrahend PositiveUint32.
+     * @returns `a - b` clamped to [1, 4294967295] as a PositiveUint32 (minimum 1).
+     */
+    readonly sub: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    /**
+     * Multiplies two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns `a * b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    readonly mul: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
+    /**
+     * Divides one PositiveUint32 by another using floor division.
+     * @param a The dividend PositiveUint32.
+     * @param b The divisor PositiveUint32.
+     * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    readonly div: (x: WithSmallInt<PositiveUint32, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly "> -2^16": true;
+        readonly "> -2^32": true;
+        readonly ">= -2^15": true;
+        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;
+};
+//# sourceMappingURL=positive-uint32.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc;IACzB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-uint32.mjs

@@ -0,0 +1,139 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a positive integer in [1, 2^32)';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 1,
+    MAX_VALUE: 2 ** 32 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a PositiveUint32 (32-bit positive unsigned integer in the range [1, 2^32)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveUint32, `false` otherwise.
+ */
+const isPositiveUint32 = is;
+/**
+ * Casts a number to a PositiveUint32 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveUint32 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^32).
+ * @example
+ * ```typescript
+ * const x = asPositiveUint32(1000); // PositiveUint32
+ * const y = asPositiveUint32(4294967295); // PositiveUint32
+ * // asPositiveUint32(0); // throws TypeError
+ * // asPositiveUint32(-1); // throws TypeError
+ * // asPositiveUint32(4294967296); // throws TypeError
+ * ```
+ */
+const asPositiveUint32 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit positive unsigned integers.
+ *
+ * All operations automatically clamp results to the valid PositiveUint32 range [1, 4294967295].
+ * This ensures that all arithmetic maintains the 32-bit positive unsigned integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveUint32(4000000000);
+ * const b = asPositiveUint32(1000000000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveUint32.add(a, b);       // PositiveUint32 (4294967295 - clamped to MAX_VALUE)
+ * const diff = PositiveUint32.sub(a, b);      // PositiveUint32 (3000000000)
+ * const reverseDiff = PositiveUint32.sub(b, a); // PositiveUint32 (1 - clamped to MIN_VALUE)
+ * const product = PositiveUint32.mul(a, b);   // PositiveUint32 (4294967295 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveUint32.clamp(-100);     // PositiveUint32 (1)
+ * const minimum = PositiveUint32.min(a, b);       // PositiveUint32 (1000000000)
+ * const maximum = PositiveUint32.max(a, b);       // PositiveUint32 (4000000000)
+ *
+ * // Utility operations
+ * const random = PositiveUint32.random();         // PositiveUint32 (random value in [1, 4294967295])
+ * const power = PositiveUint32.pow(asPositiveUint32(2), asPositiveUint32(20)); // PositiveUint32 (1048576)
+ * ```
+ */
+const PositiveUint32 = {
+    /**
+     * Type guard to check if a value is a PositiveUint32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit positive unsigned integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 32-bit positive unsigned integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 32-bit positive unsigned integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns The minimum value as a PositiveUint32.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns The maximum value as a PositiveUint32.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the PositiveUint32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    clamp,
+    /**
+     * Generates a random PositiveUint32 value within the valid range.
+     * @returns A random PositiveUint32 between 1 and 4294967295.
+     */
+    random,
+    /**
+     * Raises a PositiveUint32 to the power of another PositiveUint32.
+     * @param a The base PositiveUint32.
+     * @param b The exponent PositiveUint32.
+     * @returns `a ** b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    pow,
+    /**
+     * Adds two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns `a + b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    add,
+    /**
+     * Subtracts one PositiveUint32 from another.
+     * @param a The minuend PositiveUint32.
+     * @param b The subtrahend PositiveUint32.
+     * @returns `a - b` clamped to [1, 4294967295] as a PositiveUint32 (minimum 1).
+     */
+    sub,
+    /**
+     * Multiplies two PositiveUint32 values.
+     * @param a The first PositiveUint32.
+     * @param b The second PositiveUint32.
+     * @returns `a * b` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    mul,
+    /**
+     * Divides one PositiveUint32 by another using floor division.
+     * @param a The dividend PositiveUint32.
+     * @param b The divisor PositiveUint32.
+     * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a PositiveUint32.
+     */
+    div,
+};
+
+export { PositiveUint32, asPositiveUint32, isPositiveUint32 };
+//# sourceMappingURL=positive-uint32.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-uint32.mjs","sources":["../../../src/number/branded-types/positive-uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;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;;;;AAIG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;;AAaG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}