ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,138 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative safe integer';
+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,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    MAX_VALUE: Number.MAX_SAFE_INTEGER,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a SafeUint.
+ * @param value The value to check.
+ * @returns `true` if the value is a SafeUint, `false` otherwise.
+ */
+const isSafeUint = is;
+/**
+ * Casts a number to a SafeUint type.
+ * @param value The value to cast.
+ * @returns The value as a SafeUint type.
+ * @throws {TypeError} If the value is not a non-negative safe integer.
+ * @example
+ * ```typescript
+ * const x = asSafeUint(5); // SafeUint
+ * const y = asSafeUint(0); // SafeUint
+ * // asSafeUint(-1); // throws TypeError
+ * // asSafeUint(1.5); // throws TypeError
+ * ```
+ */
+const asSafeUint = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for safe unsigned integers.
+ *
+ * All operations automatically clamp results to the safe unsigned integer range [0, MAX_SAFE_INTEGER].
+ * This ensures that all arithmetic maintains both the non-negative constraint and IEEE 754 precision guarantees,
+ * preventing precision loss while ensuring results are never negative.
+ *
+ * @example
+ * ```typescript
+ * const a = asSafeUint(9007199254740000);  // Near MAX_SAFE_INTEGER
+ * const b = asSafeUint(1000);
+ *
+ * // Arithmetic operations with safe unsigned range clamping
+ * const sum = SafeUint.add(a, b);          // SafeUint (clamped to MAX_SAFE_INTEGER)
+ * const diff = SafeUint.sub(b, a);         // SafeUint (0 - clamped to MIN_VALUE)
+ * const product = SafeUint.mul(a, b);      // SafeUint (clamped to MAX_SAFE_INTEGER)
+ *
+ * // Range operations
+ * const clamped = SafeUint.clamp(-100);        // SafeUint (0)
+ * const minimum = SafeUint.min(a, b);          // SafeUint (1000)
+ * const maximum = SafeUint.max(a, b);          // SafeUint (a)
+ *
+ * // Utility operations
+ * const random = SafeUint.random();            // SafeUint (random safe unsigned integer)
+ * const power = SafeUint.pow(asSafeUint(2), asSafeUint(20)); // SafeUint (1048576)
+ * ```
+ */
+const SafeUint = {
+    /**
+     * Type guard to check if a value is a SafeUint.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-negative safe integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a safe unsigned integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum safe integer value (2^53 - 1).
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two SafeUint values.
+     * @param a The first SafeUint.
+     * @param b The second SafeUint.
+     * @returns The minimum value as a SafeUint.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two SafeUint values.
+     * @param a The first SafeUint.
+     * @param b The second SafeUint.
+     * @returns The maximum value as a SafeUint.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the safe unsigned integer range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
+     */
+    clamp,
+    /**
+     * Generates a random SafeUint value within the valid range.
+     * @returns A random SafeUint between 0 and MAX_SAFE_INTEGER.
+     */
+    random,
+    /**
+     * Raises a SafeUint to the power of another SafeUint.
+     * @param a The base SafeUint.
+     * @param b The exponent SafeUint.
+     * @returns `a ** b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
+     */
+    pow,
+    /**
+     * Adds two SafeUint values.
+     * @param a The first SafeUint.
+     * @param b The second SafeUint.
+     * @returns `a + b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
+     */
+    add,
+    /**
+     * Subtracts one SafeUint from another.
+     * @param a The minuend SafeUint.
+     * @param b The subtrahend SafeUint.
+     * @returns `a - b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two SafeUint values.
+     * @param a The first SafeUint.
+     * @param b The second SafeUint.
+     * @returns `a * b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
+     */
+    mul,
+    /**
+     * Divides one SafeUint by another using floor division.
+     * @param a The dividend SafeUint.
+     * @param b The divisor SafeUint.
+     * @returns `⌊a / b⌋` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
+     */
+    div,
+};
+
+export { SafeUint, asSafeUint, isSafeUint };
+//# sourceMappingURL=safe-uint.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safe-uint.mjs","sources":["../../../src/number/branded-types/safe-uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,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;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;;;;;AAYG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,QAAQ,GAAG;AACtB;;;;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/uint.d.mts

@@ -0,0 +1,144 @@
+/**
+ * Checks if a number is a Uint.
+ * @param value The value to check.
+ * @returns `true` if the value is a Uint, `false` otherwise.
+ */
+export declare const isUint: (a: number) => a is NonNegativeInt;
+/**
+ * Casts a number to a Uint type.
+ * @param value The value to cast.
+ * @returns The value as a Uint type.
+ * @throws {TypeError} If the value is not a non-negative integer.
+ * @example
+ * ```typescript
+ * const x = asUint(5); // Uint
+ * const y = asUint(0); // Uint
+ * // asUint(-1); // throws TypeError
+ * // asUint(1.5); // throws TypeError
+ * ```
+ */
+export declare const asUint: <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 Finite: true;
+    readonly Int: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for unsigned integers.
+ *
+ * All operations maintain the non-negative constraint by clamping negative results to 0.
+ * This ensures that all arithmetic preserves the unsigned integer property.
+ *
+ * @example
+ * ```typescript
+ * const a = asUint(100);
+ * const b = asUint(150);
+ *
+ * // Arithmetic operations with non-negative clamping
+ * const sum = Uint.add(a, b);       // Uint (250)
+ * const diff = Uint.sub(a, b);      // Uint (0 - clamped to MIN_VALUE)
+ * const product = Uint.mul(a, b);   // Uint (15000)
+ * const quotient = Uint.div(b, a);  // Uint (1)
+ *
+ * // Range operations
+ * const clamped = Uint.clamp(-50);      // Uint (0)
+ * const minimum = Uint.min(a, b);       // Uint (100)
+ * const maximum = Uint.max(a, b);       // Uint (150)
+ *
+ * // Utility operations
+ * const random = Uint.random();         // Uint (random non-negative integer)
+ * const power = Uint.pow(asUint(2), asUint(8)); // Uint (256)
+ * ```
+ */
+export declare const Uint: {
+    /**
+     * Type guard to check if a value is a Uint.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-negative integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonNegativeInt;
+    /**
+     * The minimum value for an unsigned integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 0;
+    /**
+     * Returns the smaller of two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns The minimum value as a Uint.
+     */
+    readonly min: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    /**
+     * Returns the larger of two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns The maximum value as a Uint.
+     */
+    readonly max: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    /**
+     * Clamps a number to the Uint range (non-negative).
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, +∞) as a Uint.
+     */
+    readonly clamp: (x: number) => NonNegativeInt;
+    /**
+     * Generates a random Uint value.
+     * @returns A random non-negative integer as a Uint.
+     */
+    readonly random: (min: WithSmallInt<NonNegativeInt, 40>, max: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    /**
+     * Raises a Uint to the power of another Uint.
+     * @param a The base Uint.
+     * @param b The exponent Uint.
+     * @returns `a ** b` clamped to [0, +∞) as a Uint.
+     */
+    readonly pow: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    /**
+     * Adds two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns `a + b` clamped to [0, +∞) as a Uint.
+     */
+    readonly add: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    /**
+     * Subtracts one Uint from another.
+     * @param a The minuend Uint.
+     * @param b The subtrahend Uint.
+     * @returns `a - b` clamped to [0, +∞) as a Uint (minimum 0).
+     */
+    readonly sub: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    /**
+     * Multiplies two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns `a * b` clamped to [0, +∞) as a Uint.
+     */
+    readonly mul: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    /**
+     * Divides one Uint by another using floor division.
+     * @param a The dividend Uint.
+     * @param b The divisor Uint.
+     * @returns `⌊a / b⌋` clamped to [0, +∞) as a Uint.
+     */
+    readonly div: (x: WithSmallInt<NonNegativeInt, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+        readonly 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 Finite: true;
+        readonly Int: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => NonNegativeInt;
+};
+//# sourceMappingURL=uint.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,eAAO,MAAM,MAAM,oCAAK,CAAC;AAEzB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,IAAI;IACf;;;;OAIG;;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/uint.mjs

@@ -0,0 +1,132 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative integer';
+const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    MIN_VALUE: 0,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a Uint.
+ * @param value The value to check.
+ * @returns `true` if the value is a Uint, `false` otherwise.
+ */
+const isUint = is;
+/**
+ * Casts a number to a Uint type.
+ * @param value The value to cast.
+ * @returns The value as a Uint type.
+ * @throws {TypeError} If the value is not a non-negative integer.
+ * @example
+ * ```typescript
+ * const x = asUint(5); // Uint
+ * const y = asUint(0); // Uint
+ * // asUint(-1); // throws TypeError
+ * // asUint(1.5); // throws TypeError
+ * ```
+ */
+const asUint = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for unsigned integers.
+ *
+ * All operations maintain the non-negative constraint by clamping negative results to 0.
+ * This ensures that all arithmetic preserves the unsigned integer property.
+ *
+ * @example
+ * ```typescript
+ * const a = asUint(100);
+ * const b = asUint(150);
+ *
+ * // Arithmetic operations with non-negative clamping
+ * const sum = Uint.add(a, b);       // Uint (250)
+ * const diff = Uint.sub(a, b);      // Uint (0 - clamped to MIN_VALUE)
+ * const product = Uint.mul(a, b);   // Uint (15000)
+ * const quotient = Uint.div(b, a);  // Uint (1)
+ *
+ * // Range operations
+ * const clamped = Uint.clamp(-50);      // Uint (0)
+ * const minimum = Uint.min(a, b);       // Uint (100)
+ * const maximum = Uint.max(a, b);       // Uint (150)
+ *
+ * // Utility operations
+ * const random = Uint.random();         // Uint (random non-negative integer)
+ * const power = Uint.pow(asUint(2), asUint(8)); // Uint (256)
+ * ```
+ */
+const Uint = {
+    /**
+     * Type guard to check if a value is a Uint.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-negative integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for an unsigned integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * Returns the smaller of two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns The minimum value as a Uint.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns The maximum value as a Uint.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the Uint range (non-negative).
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, +∞) as a Uint.
+     */
+    clamp,
+    /**
+     * Generates a random Uint value.
+     * @returns A random non-negative integer as a Uint.
+     */
+    random,
+    /**
+     * Raises a Uint to the power of another Uint.
+     * @param a The base Uint.
+     * @param b The exponent Uint.
+     * @returns `a ** b` clamped to [0, +∞) as a Uint.
+     */
+    pow,
+    /**
+     * Adds two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns `a + b` clamped to [0, +∞) as a Uint.
+     */
+    add,
+    /**
+     * Subtracts one Uint from another.
+     * @param a The minuend Uint.
+     * @param b The subtrahend Uint.
+     * @returns `a - b` clamped to [0, +∞) as a Uint (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two Uint values.
+     * @param a The first Uint.
+     * @param b The second Uint.
+     * @returns `a * b` clamped to [0, +∞) as a Uint.
+     */
+    mul,
+    /**
+     * Divides one Uint by another using floor division.
+     * @param a The dividend Uint.
+     * @param b The divisor Uint.
+     * @returns `⌊a / b⌋` clamped to [0, +∞) as a Uint.
+     */
+    div,
+};
+
+export { Uint, asUint, isUint };
+//# sourceMappingURL=uint.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,MAAM,EACJ,SAAS,EACT,GAAG,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,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;AAYG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,IAAI,GAAG;AAClB;;;;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;;;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/uint16.d.mts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM;IACjB;;;;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"}