ts-data-forge 1.0.0 → 1.0.1

package/dist/number/branded-types/non-negative-finite-number.mjs

@@ -0,0 +1,160 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative finite number';
+const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
+    MIN_VALUE: 0,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+const floor = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.floor(x);
+const ceil = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.ceil(x);
+const round = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.round(x);
+/**
+ * Checks if a number is a NonNegativeFiniteNumber (a finite number >= 0).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonNegativeFiniteNumber, `false` otherwise.
+ */
+const isNonNegativeFiniteNumber = is;
+/**
+ * Casts a number to a NonNegativeFiniteNumber type.
+ * @param value The value to cast.
+ * @returns The value as a NonNegativeFiniteNumber type.
+ * @throws {TypeError} If the value is not a non-negative finite number.
+ * @example
+ * ```typescript
+ * const x = asNonNegativeFiniteNumber(5.5); // NonNegativeFiniteNumber
+ * const y = asNonNegativeFiniteNumber(0); // NonNegativeFiniteNumber
+ * // asNonNegativeFiniteNumber(-1); // throws TypeError
+ * // asNonNegativeFiniteNumber(Infinity); // throws TypeError
+ * ```
+ */
+const asNonNegativeFiniteNumber = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for non-negative finite numbers.
+ *
+ * All operations maintain the non-negative constraint by clamping negative results to 0,
+ * while ensuring results remain finite (excluding NaN and Infinity). This type is useful
+ * for representing measurements, distances, weights, and other inherently non-negative values.
+ *
+ * @example
+ * ```typescript
+ * const distance = asNonNegativeFiniteNumber(5.5);
+ * const speed = asNonNegativeFiniteNumber(2.2);
+ *
+ * // Arithmetic operations with non-negative clamping
+ * const total = NonNegativeFiniteNumber.add(distance, speed);        // NonNegativeFiniteNumber (7.7)
+ * const diff = NonNegativeFiniteNumber.sub(speed, distance);        // NonNegativeFiniteNumber (0 - clamped)
+ * const area = NonNegativeFiniteNumber.mul(distance, speed);        // NonNegativeFiniteNumber (12.1)
+ * const ratio = NonNegativeFiniteNumber.div(distance, speed);       // NonNegativeFiniteNumber (2.5)
+ *
+ * // Range operations
+ * const clamped = NonNegativeFiniteNumber.clamp(-10.5);             // NonNegativeFiniteNumber (0)
+ * const minimum = NonNegativeFiniteNumber.min(distance, speed);     // NonNegativeFiniteNumber (2.2)
+ * const maximum = NonNegativeFiniteNumber.max(distance, speed);     // NonNegativeFiniteNumber (5.5)
+ *
+ * // Rounding operations (return Uint)
+ * const pixels = NonNegativeFiniteNumber.round(distance);           // Uint (6)
+ * const floorValue = NonNegativeFiniteNumber.floor(distance);       // Uint (5)
+ * const ceilValue = NonNegativeFiniteNumber.ceil(distance);         // Uint (6)
+ * ```
+ */
+const NonNegativeFiniteNumber = {
+    /**
+     * Type guard to check if a value is a NonNegativeFiniteNumber.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-negative finite number, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a non-negative finite number.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * Returns the smaller of two NonNegativeFiniteNumber values.
+     * @param a The first NonNegativeFiniteNumber.
+     * @param b The second NonNegativeFiniteNumber.
+     * @returns The minimum value as a NonNegativeFiniteNumber.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NonNegativeFiniteNumber values.
+     * @param a The first NonNegativeFiniteNumber.
+     * @param b The second NonNegativeFiniteNumber.
+     * @returns The maximum value as a NonNegativeFiniteNumber.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the non-negative finite range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, +∞) as a NonNegativeFiniteNumber.
+     */
+    clamp,
+    /**
+     * Rounds down a NonNegativeFiniteNumber to the nearest integer.
+     * @param x The NonNegativeFiniteNumber to round down.
+     * @returns The floor value as a Uint.
+     */
+    floor,
+    /**
+     * Rounds up a NonNegativeFiniteNumber to the nearest integer.
+     * @param x The NonNegativeFiniteNumber to round up.
+     * @returns The ceiling value as a Uint.
+     */
+    ceil,
+    /**
+     * Rounds a NonNegativeFiniteNumber to the nearest integer.
+     * @param x The NonNegativeFiniteNumber to round.
+     * @returns The rounded value as a Uint.
+     */
+    round,
+    /**
+     * Generates a random NonNegativeFiniteNumber value.
+     * @returns A random non-negative finite number.
+     */
+    random,
+    /**
+     * Raises a NonNegativeFiniteNumber to the power of another NonNegativeFiniteNumber.
+     * @param a The base NonNegativeFiniteNumber.
+     * @param b The exponent NonNegativeFiniteNumber.
+     * @returns `a ** b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
+     */
+    pow,
+    /**
+     * Adds two NonNegativeFiniteNumber values.
+     * @param a The first NonNegativeFiniteNumber.
+     * @param b The second NonNegativeFiniteNumber.
+     * @returns `a + b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
+     */
+    add,
+    /**
+     * Subtracts one NonNegativeFiniteNumber from another.
+     * @param a The minuend NonNegativeFiniteNumber.
+     * @param b The subtrahend NonNegativeFiniteNumber.
+     * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two NonNegativeFiniteNumber values.
+     * @param a The first NonNegativeFiniteNumber.
+     * @param b The second NonNegativeFiniteNumber.
+     * @returns `a * b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
+     */
+    mul,
+    /**
+     * Divides one NonNegativeFiniteNumber by another.
+     * @param a The dividend NonNegativeFiniteNumber.
+     * @param b The divisor NonNegativeFiniteNumber.
+     * @returns `a / b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
+     */
+    div,
+};
+
+export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber };
+//# sourceMappingURL=non-negative-finite-number.mjs.map

package/dist/number/branded-types/non-negative-finite-number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,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,iBAAiB,CAI1D;AACA,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAM5E;;;;AAIG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;AAYG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;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/non-negative-int16.d.mts

@@ -0,0 +1,160 @@
+/**
+ * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer in the range [0, 2^15)).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonNegativeInt16, `false` otherwise.
+ */
+export declare const isNonNegativeInt16: (a: number) => a is NonNegativeInt16;
+/**
+ * Casts a number to a NonNegativeInt16 type.
+ * @param value The value to cast.
+ * @returns The value as a NonNegativeInt16 type.
+ * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15).
+ * @example
+ * ```typescript
+ * const x = asNonNegativeInt16(1000); // NonNegativeInt16
+ * const y = asNonNegativeInt16(0); // NonNegativeInt16
+ * // asNonNegativeInt16(-1); // throws TypeError
+ * // asNonNegativeInt16(32768); // throws TypeError
+ * ```
+ */
+export declare const asNonNegativeInt16: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    readonly ">=0": true;
+    readonly "< 2^15": 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 non-negative integers.
+ *
+ * All operations automatically clamp results to the valid NonNegativeInt16 range [0, 32767].
+ * This ensures that all arithmetic maintains the 16-bit non-negative integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonNegativeInt16(30000);
+ * const b = asNonNegativeInt16(5000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = NonNegativeInt16.add(a, b);       // NonNegativeInt16 (32767 - clamped to MAX_VALUE)
+ * const diff = NonNegativeInt16.sub(a, b);      // NonNegativeInt16 (25000)
+ * const reverseDiff = NonNegativeInt16.sub(b, a); // NonNegativeInt16 (0 - clamped to MIN_VALUE)
+ * const product = NonNegativeInt16.mul(a, b);   // NonNegativeInt16 (32767 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = NonNegativeInt16.clamp(-100);     // NonNegativeInt16 (0)
+ * const minimum = NonNegativeInt16.min(a, b);       // NonNegativeInt16 (5000)
+ * const maximum = NonNegativeInt16.max(a, b);       // NonNegativeInt16 (30000)
+ *
+ * // Utility operations
+ * const random = NonNegativeInt16.random();         // NonNegativeInt16 (random value in [0, 32767])
+ * const power = NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(10)); // NonNegativeInt16 (1024)
+ * ```
+ */
+export declare const NonNegativeInt16: {
+    /**
+     * Type guard to check if a value is a NonNegativeInt16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit non-negative integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonNegativeInt16;
+    /**
+     * The minimum value for a 16-bit non-negative integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 0;
+    /**
+     * The maximum value for a 16-bit non-negative integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns The minimum value as a NonNegativeInt16.
+     */
+    readonly min: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
+    /**
+     * Returns the larger of two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns The maximum value as a NonNegativeInt16.
+     */
+    readonly max: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
+    /**
+     * Clamps a number to the NonNegativeInt16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    readonly clamp: (x: number) => NonNegativeInt16;
+    /**
+     * Generates a random NonNegativeInt16 value within the valid range.
+     * @returns A random NonNegativeInt16 between 0 and 32767.
+     */
+    readonly random: (min: WithSmallInt<NonNegativeInt16, 40>, max: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    /**
+     * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
+     * @param a The base NonNegativeInt16.
+     * @param b The exponent NonNegativeInt16.
+     * @returns `a ** b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    readonly pow: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    /**
+     * Adds two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns `a + b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    readonly add: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    /**
+     * Subtracts one NonNegativeInt16 from another.
+     * @param a The minuend NonNegativeInt16.
+     * @param b The subtrahend NonNegativeInt16.
+     * @returns `a - b` clamped to [0, 32767] as a NonNegativeInt16 (minimum 0).
+     */
+    readonly sub: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    /**
+     * Multiplies two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns `a * b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    readonly mul: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    /**
+     * Divides one NonNegativeInt16 by another using floor division.
+     * @param a The dividend NonNegativeInt16.
+     * @param b The divisor NonNegativeInt16.
+     * @returns `⌊a / b⌋` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    readonly div: (x: WithSmallInt<NonNegativeInt16, 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^15": 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;
+    }>>) => NonNegativeInt16;
+};
+//# sourceMappingURL=non-negative-int16.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;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/non-negative-int16.mjs

@@ -0,0 +1,138 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative integer in [0, 2^15)';
+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: 0,
+    MAX_VALUE: 2 ** 15 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer in the range [0, 2^15)).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonNegativeInt16, `false` otherwise.
+ */
+const isNonNegativeInt16 = is;
+/**
+ * Casts a number to a NonNegativeInt16 type.
+ * @param value The value to cast.
+ * @returns The value as a NonNegativeInt16 type.
+ * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15).
+ * @example
+ * ```typescript
+ * const x = asNonNegativeInt16(1000); // NonNegativeInt16
+ * const y = asNonNegativeInt16(0); // NonNegativeInt16
+ * // asNonNegativeInt16(-1); // throws TypeError
+ * // asNonNegativeInt16(32768); // throws TypeError
+ * ```
+ */
+const asNonNegativeInt16 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 16-bit non-negative integers.
+ *
+ * All operations automatically clamp results to the valid NonNegativeInt16 range [0, 32767].
+ * This ensures that all arithmetic maintains the 16-bit non-negative integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonNegativeInt16(30000);
+ * const b = asNonNegativeInt16(5000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = NonNegativeInt16.add(a, b);       // NonNegativeInt16 (32767 - clamped to MAX_VALUE)
+ * const diff = NonNegativeInt16.sub(a, b);      // NonNegativeInt16 (25000)
+ * const reverseDiff = NonNegativeInt16.sub(b, a); // NonNegativeInt16 (0 - clamped to MIN_VALUE)
+ * const product = NonNegativeInt16.mul(a, b);   // NonNegativeInt16 (32767 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = NonNegativeInt16.clamp(-100);     // NonNegativeInt16 (0)
+ * const minimum = NonNegativeInt16.min(a, b);       // NonNegativeInt16 (5000)
+ * const maximum = NonNegativeInt16.max(a, b);       // NonNegativeInt16 (30000)
+ *
+ * // Utility operations
+ * const random = NonNegativeInt16.random();         // NonNegativeInt16 (random value in [0, 32767])
+ * const power = NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(10)); // NonNegativeInt16 (1024)
+ * ```
+ */
+const NonNegativeInt16 = {
+    /**
+     * Type guard to check if a value is a NonNegativeInt16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit non-negative integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 16-bit non-negative integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 16-bit non-negative integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns The minimum value as a NonNegativeInt16.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns The maximum value as a NonNegativeInt16.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the NonNegativeInt16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    clamp,
+    /**
+     * Generates a random NonNegativeInt16 value within the valid range.
+     * @returns A random NonNegativeInt16 between 0 and 32767.
+     */
+    random,
+    /**
+     * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
+     * @param a The base NonNegativeInt16.
+     * @param b The exponent NonNegativeInt16.
+     * @returns `a ** b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    pow,
+    /**
+     * Adds two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns `a + b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    add,
+    /**
+     * Subtracts one NonNegativeInt16 from another.
+     * @param a The minuend NonNegativeInt16.
+     * @param b The subtrahend NonNegativeInt16.
+     * @returns `a - b` clamped to [0, 32767] as a NonNegativeInt16 (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two NonNegativeInt16 values.
+     * @param a The first NonNegativeInt16.
+     * @param b The second NonNegativeInt16.
+     * @returns `a * b` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    mul,
+    /**
+     * Divides one NonNegativeInt16 by another using floor division.
+     * @param a The dividend NonNegativeInt16.
+     * @param b The divisor NonNegativeInt16.
+     * @returns `⌊a / b⌋` clamped to [0, 32767] as a NonNegativeInt16.
+     */
+    div,
+};
+
+export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 };
+//# sourceMappingURL=non-negative-int16.mjs.map

package/dist/number/branded-types/non-negative-int16.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-negative-int16.mjs","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;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/non-negative-int32.d.mts

@@ -0,0 +1,156 @@
+/**
+ * Checks if a number is a NonNegativeInt32 (32-bit non-negative signed integer in the range [0, 2^31)).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonNegativeInt32, `false` otherwise.
+ */
+export declare const isNonNegativeInt32: (a: number) => a is NonNegativeInt32;
+/**
+ * Casts a number to a NonNegativeInt32 type.
+ * @param value The value to cast.
+ * @returns The value as a NonNegativeInt32 type.
+ * @throws {TypeError} If the value is not a non-negative integer in [0, 2^31).
+ * @example
+ * ```typescript
+ * const x = asNonNegativeInt32(1000); // NonNegativeInt32
+ * const y = asNonNegativeInt32(0); // NonNegativeInt32
+ * // asNonNegativeInt32(-1); // throws TypeError
+ * // asNonNegativeInt32(2147483648); // throws TypeError
+ * ```
+ */
+export declare const asNonNegativeInt32: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    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;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit non-negative integers.
+ *
+ * All operations automatically clamp results to the valid NonNegativeInt32 range [0, 2147483647].
+ * This ensures that all arithmetic maintains the 32-bit non-negative integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonNegativeInt32(2000000000);
+ * const b = asNonNegativeInt32(500000000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = NonNegativeInt32.add(a, b);       // NonNegativeInt32 (2147483647 - clamped to MAX_VALUE)
+ * const diff = NonNegativeInt32.sub(a, b);      // NonNegativeInt32 (1500000000)
+ * const reverseDiff = NonNegativeInt32.sub(b, a); // NonNegativeInt32 (0 - clamped to MIN_VALUE)
+ * const product = NonNegativeInt32.mul(a, b);   // NonNegativeInt32 (2147483647 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = NonNegativeInt32.clamp(-1000);     // NonNegativeInt32 (0)
+ * const minimum = NonNegativeInt32.min(a, b);        // NonNegativeInt32 (500000000)
+ * const maximum = NonNegativeInt32.max(a, b);        // NonNegativeInt32 (2000000000)
+ *
+ * // Utility operations
+ * const random = NonNegativeInt32.random();          // NonNegativeInt32 (random value in [0, 2147483647])
+ * const power = NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(20)); // NonNegativeInt32 (1048576)
+ * ```
+ */
+export declare const NonNegativeInt32: {
+    /**
+     * Type guard to check if a value is a NonNegativeInt32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit non-negative integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonNegativeInt32;
+    /**
+     * The minimum value for a 32-bit non-negative integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 0;
+    /**
+     * The maximum value for a 32-bit non-negative integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns The minimum value as a NonNegativeInt32.
+     */
+    readonly min: (...values: readonly WithSmallInt<NonNegativeInt32, 40>[]) => NonNegativeInt32;
+    /**
+     * Returns the larger of two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns The maximum value as a NonNegativeInt32.
+     */
+    readonly max: (...values: readonly WithSmallInt<NonNegativeInt32, 40>[]) => NonNegativeInt32;
+    /**
+     * Clamps a number to the NonNegativeInt32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    readonly clamp: (x: number) => NonNegativeInt32;
+    /**
+     * Generates a random NonNegativeInt32 value within the valid range.
+     * @returns A random NonNegativeInt32 between 0 and 2147483647.
+     */
+    readonly random: (min: WithSmallInt<NonNegativeInt32, 40>, max: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    /**
+     * Raises a NonNegativeInt32 to the power of another NonNegativeInt32.
+     * @param a The base NonNegativeInt32.
+     * @param b The exponent NonNegativeInt32.
+     * @returns `a ** b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    readonly pow: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    /**
+     * Adds two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns `a + b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    readonly add: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    /**
+     * Subtracts one NonNegativeInt32 from another.
+     * @param a The minuend NonNegativeInt32.
+     * @param b The subtrahend NonNegativeInt32.
+     * @returns `a - b` clamped to [0, 2147483647] as a NonNegativeInt32 (minimum 0).
+     */
+    readonly sub: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    /**
+     * Multiplies two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns `a * b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    readonly mul: (x: WithSmallInt<NonNegativeInt32, 40>, y: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    /**
+     * Divides one NonNegativeInt32 by another using floor division.
+     * @param a The dividend NonNegativeInt32.
+     * @param b The divisor NonNegativeInt32.
+     * @returns `⌊a / b⌋` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    readonly div: (x: WithSmallInt<NonNegativeInt32, 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^31": true;
+        readonly "< 2^32": true;
+        readonly Finite: true;
+        readonly Int: true;
+        readonly SafeInt: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => NonNegativeInt32;
+};
+//# sourceMappingURL=non-negative-int32.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;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"}