ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,242 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+/**
+ * Type guard that checks if a value is an integer.
+ *
+ * Returns `true` if the value is any integer (positive, negative, or zero),
+ * with no fractional component. This includes values outside the safe integer
+ * range, unlike SafeInt.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an integer, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isInt(5);        // true
+ * isInt(-10);      // true
+ * isInt(0);        // true
+ * isInt(5.5);      // false
+ * isInt(NaN);      // false
+ * isInt(Infinity); // false
+ * ```
+ */
+export declare const isInt: (a: number) => a is Int;
+/**
+ * Casts a number to an Int branded type.
+ *
+ * This function validates that the input is an integer and returns it with
+ * the Int brand. Throws a TypeError if the value has a fractional component
+ * or is not a finite number.
+ *
+ * @param value - The value to cast
+ * @returns The value as an Int branded type
+ * @throws {TypeError} If the value is not an integer
+ *
+ * @example
+ * ```typescript
+ * const x = asInt(5);    // Int
+ * const y = asInt(-10);  // Int
+ * const z = asInt(0);    // Int
+ *
+ * // These throw TypeError:
+ * // asInt(5.5);         // Not an integer
+ * // asInt(NaN);         // Not a number
+ * // asInt(Infinity);    // Not finite
+ * ```
+ */
+export declare const asInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe operations for Int branded types.
+ *
+ * The Int type represents any integer value (no fractional component) without
+ * range restrictions. All operations preserve the integer constraint, using
+ * floor division for division operations.
+ *
+ * Unlike SafeInt, Int allows values outside the safe integer range
+ * (±2^53 - 1), but be aware that very large integers may lose precision
+ * in JavaScript's number type.
+ *
+ * @example
+ * ```typescript
+ * // Type validation
+ * Int.is(42);      // true
+ * Int.is(3.14);    // false
+ * Int.is(-0);      // true (negative zero is an integer)
+ *
+ * // Basic arithmetic
+ * const a = asInt(10);
+ * const b = asInt(3);
+ *
+ * const sum = Int.add(a, b);      // Int (13)
+ * const diff = Int.sub(a, b);     // Int (7)
+ * const product = Int.mul(a, b);  // Int (30)
+ * const quotient = Int.div(a, b); // Int (3) - floor division
+ * const power = Int.pow(a, b);    // Int (1000)
+ *
+ * // Utility operations
+ * const absolute = Int.abs(asInt(-42));    // Int (42)
+ * const minimum = Int.min(a, b, asInt(5)); // Int (3)
+ * const maximum = Int.max(a, b, asInt(5)); // Int (10)
+ *
+ * // Random generation
+ * const die = Int.random(asInt(1), asInt(6)); // Random Int in [1, 6]
+ * ```
+ */
+export declare const Int: {
+    /**
+     * Type guard that checks if a value is an integer.
+     *
+     * @param value - The value to check
+     * @returns `true` if the value is an integer, `false` otherwise
+     *
+     * @see {@link isInt} for usage examples
+     */
+    readonly is: (a: number) => a is Int;
+    /**
+     * Returns the absolute value of an integer.
+     *
+     * The result is always non-negative and maintains the Int brand.
+     * Note that Math.abs(Number.MIN_SAFE_INTEGER) exceeds Number.MAX_SAFE_INTEGER,
+     * so use SafeInt for guaranteed precision.
+     *
+     * @param a - The integer value
+     * @returns The absolute value as a non-negative Int
+     *
+     * @example
+     * ```typescript
+     * Int.abs(asInt(-5));  // Int (5)
+     * Int.abs(asInt(3));   // Int (3)
+     * Int.abs(asInt(-0));  // Int (0)
+     * ```
+     */
+    readonly abs: (x: WithSmallInt<Int, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int>;
+    /**
+     * Returns the minimum value from a list of integers.
+     *
+     * @param values - The integers to compare (at least one required)
+     * @returns The smallest value as an Int
+     *
+     * @example
+     * ```typescript
+     * Int.min(asInt(5), asInt(3));           // Int (3)
+     * Int.min(asInt(-10), asInt(0), asInt(10)); // Int (-10)
+     * ```
+     */
+    readonly min: (...values: readonly WithSmallInt<Int, 40>[]) => Int;
+    /**
+     * Returns the maximum value from a list of integers.
+     *
+     * @param values - The integers to compare (at least one required)
+     * @returns The largest value as an Int
+     *
+     * @example
+     * ```typescript
+     * Int.max(asInt(5), asInt(3));           // Int (5)
+     * Int.max(asInt(-10), asInt(0), asInt(10)); // Int (10)
+     * ```
+     */
+    readonly max: (...values: readonly WithSmallInt<Int, 40>[]) => Int;
+    /**
+     * Generates a random integer within the specified range (inclusive).
+     *
+     * The range is inclusive on both ends, so random(1, 6) can return
+     * any of: 1, 2, 3, 4, 5, or 6.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random Int in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Dice roll
+     * const d6 = Int.random(asInt(1), asInt(6));
+     *
+     * // Random array index
+     * const index = Int.random(asInt(0), asInt(array.length - 1));
+     *
+     * // Can generate negative values
+     * const temp = Int.random(asInt(-10), asInt(10));
+     * ```
+     */
+    readonly random: (min: WithSmallInt<Int, 40>, max: WithSmallInt<Int, 40>) => Int;
+    /**
+     * Raises an integer to a power.
+     * @param a - The base integer
+     * @param b - The exponent integer
+     * @returns `a ** b` as an Int
+     * @example
+     * ```typescript
+     * Int.pow(asInt(2), asInt(3)); // Int (8)
+     * ```
+     */
+    readonly pow: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    /**
+     * Adds two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a + b` as an Int
+     * @example
+     * ```typescript
+     * Int.add(asInt(5), asInt(3)); // Int (8)
+     * ```
+     */
+    readonly add: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    /**
+     * Subtracts two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a - b` as an Int
+     * @example
+     * ```typescript
+     * Int.sub(asInt(8), asInt(3)); // Int (5)
+     * ```
+     */
+    readonly sub: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    /**
+     * Multiplies two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a * b` as an Int
+     * @example
+     * ```typescript
+     * Int.mul(asInt(4), asInt(3)); // Int (12)
+     * ```
+     */
+    readonly mul: (x: WithSmallInt<Int, 40>, y: WithSmallInt<Int, 40>) => Int;
+    /**
+     * Divides two integers using floor division.
+     *
+     * Performs mathematical floor division: `⌊a / b⌋`.
+     * The result is always an integer, rounding toward negative infinity.
+     *
+     * @param a - The dividend
+     * @param b - The divisor (must be non-zero)
+     * @returns The integer quotient as an Int
+     *
+     * @example
+     * ```typescript
+     * // Positive division
+     * Int.div(asInt(10), asInt(3));   // Int (3)
+     * Int.div(asInt(9), asInt(3));    // Int (3)
+     *
+     * // Negative division (rounds toward -∞)
+     * Int.div(asInt(-10), asInt(3));  // Int (-4)
+     * Int.div(asInt(10), asInt(-3));  // Int (-4)
+     * Int.div(asInt(-10), asInt(-3)); // Int (3)
+     * ```
+     */
+    readonly div: (x: WithSmallInt<Int, 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 NaNValue: false;
+        readonly "!=0": true;
+        readonly Finite: true;
+        readonly Int: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => Int;
+};
+//# sourceMappingURL=int.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA6BlE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;OAOG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,239 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'an integer';
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    MIN_VALUE: undefined,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+/**
+ * Type guard that checks if a value is an integer.
+ *
+ * Returns `true` if the value is any integer (positive, negative, or zero),
+ * with no fractional component. This includes values outside the safe integer
+ * range, unlike SafeInt.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an integer, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isInt(5);        // true
+ * isInt(-10);      // true
+ * isInt(0);        // true
+ * isInt(5.5);      // false
+ * isInt(NaN);      // false
+ * isInt(Infinity); // false
+ * ```
+ */
+const isInt = is;
+/**
+ * Casts a number to an Int branded type.
+ *
+ * This function validates that the input is an integer and returns it with
+ * the Int brand. Throws a TypeError if the value has a fractional component
+ * or is not a finite number.
+ *
+ * @param value - The value to cast
+ * @returns The value as an Int branded type
+ * @throws {TypeError} If the value is not an integer
+ *
+ * @example
+ * ```typescript
+ * const x = asInt(5);    // Int
+ * const y = asInt(-10);  // Int
+ * const z = asInt(0);    // Int
+ *
+ * // These throw TypeError:
+ * // asInt(5.5);         // Not an integer
+ * // asInt(NaN);         // Not a number
+ * // asInt(Infinity);    // Not finite
+ * ```
+ */
+const asInt = castType;
+/**
+ * Namespace providing type-safe operations for Int branded types.
+ *
+ * The Int type represents any integer value (no fractional component) without
+ * range restrictions. All operations preserve the integer constraint, using
+ * floor division for division operations.
+ *
+ * Unlike SafeInt, Int allows values outside the safe integer range
+ * (±2^53 - 1), but be aware that very large integers may lose precision
+ * in JavaScript's number type.
+ *
+ * @example
+ * ```typescript
+ * // Type validation
+ * Int.is(42);      // true
+ * Int.is(3.14);    // false
+ * Int.is(-0);      // true (negative zero is an integer)
+ *
+ * // Basic arithmetic
+ * const a = asInt(10);
+ * const b = asInt(3);
+ *
+ * const sum = Int.add(a, b);      // Int (13)
+ * const diff = Int.sub(a, b);     // Int (7)
+ * const product = Int.mul(a, b);  // Int (30)
+ * const quotient = Int.div(a, b); // Int (3) - floor division
+ * const power = Int.pow(a, b);    // Int (1000)
+ *
+ * // Utility operations
+ * const absolute = Int.abs(asInt(-42));    // Int (42)
+ * const minimum = Int.min(a, b, asInt(5)); // Int (3)
+ * const maximum = Int.max(a, b, asInt(5)); // Int (10)
+ *
+ * // Random generation
+ * const die = Int.random(asInt(1), asInt(6)); // Random Int in [1, 6]
+ * ```
+ */
+const Int = {
+    /**
+     * Type guard that checks if a value is an integer.
+     *
+     * @param value - The value to check
+     * @returns `true` if the value is an integer, `false` otherwise
+     *
+     * @see {@link isInt} for usage examples
+     */
+    is,
+    /**
+     * Returns the absolute value of an integer.
+     *
+     * The result is always non-negative and maintains the Int brand.
+     * Note that Math.abs(Number.MIN_SAFE_INTEGER) exceeds Number.MAX_SAFE_INTEGER,
+     * so use SafeInt for guaranteed precision.
+     *
+     * @param a - The integer value
+     * @returns The absolute value as a non-negative Int
+     *
+     * @example
+     * ```typescript
+     * Int.abs(asInt(-5));  // Int (5)
+     * Int.abs(asInt(3));   // Int (3)
+     * Int.abs(asInt(-0));  // Int (0)
+     * ```
+     */
+    abs,
+    /**
+     * Returns the minimum value from a list of integers.
+     *
+     * @param values - The integers to compare (at least one required)
+     * @returns The smallest value as an Int
+     *
+     * @example
+     * ```typescript
+     * Int.min(asInt(5), asInt(3));           // Int (3)
+     * Int.min(asInt(-10), asInt(0), asInt(10)); // Int (-10)
+     * ```
+     */
+    min: min_,
+    /**
+     * Returns the maximum value from a list of integers.
+     *
+     * @param values - The integers to compare (at least one required)
+     * @returns The largest value as an Int
+     *
+     * @example
+     * ```typescript
+     * Int.max(asInt(5), asInt(3));           // Int (5)
+     * Int.max(asInt(-10), asInt(0), asInt(10)); // Int (10)
+     * ```
+     */
+    max: max_,
+    /**
+     * Generates a random integer within the specified range (inclusive).
+     *
+     * The range is inclusive on both ends, so random(1, 6) can return
+     * any of: 1, 2, 3, 4, 5, or 6.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random Int in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Dice roll
+     * const d6 = Int.random(asInt(1), asInt(6));
+     *
+     * // Random array index
+     * const index = Int.random(asInt(0), asInt(array.length - 1));
+     *
+     * // Can generate negative values
+     * const temp = Int.random(asInt(-10), asInt(10));
+     * ```
+     */
+    random,
+    /**
+     * Raises an integer to a power.
+     * @param a - The base integer
+     * @param b - The exponent integer
+     * @returns `a ** b` as an Int
+     * @example
+     * ```typescript
+     * Int.pow(asInt(2), asInt(3)); // Int (8)
+     * ```
+     */
+    pow,
+    /**
+     * Adds two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a + b` as an Int
+     * @example
+     * ```typescript
+     * Int.add(asInt(5), asInt(3)); // Int (8)
+     * ```
+     */
+    add,
+    /**
+     * Subtracts two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a - b` as an Int
+     * @example
+     * ```typescript
+     * Int.sub(asInt(8), asInt(3)); // Int (5)
+     * ```
+     */
+    sub,
+    /**
+     * Multiplies two integers.
+     * @param a - First integer
+     * @param b - Second integer
+     * @returns `a * b` as an Int
+     * @example
+     * ```typescript
+     * Int.mul(asInt(4), asInt(3)); // Int (12)
+     * ```
+     */
+    mul,
+    /**
+     * Divides two integers using floor division.
+     *
+     * Performs mathematical floor division: `⌊a / b⌋`.
+     * The result is always an integer, rounding toward negative infinity.
+     *
+     * @param a - The dividend
+     * @param b - The divisor (must be non-zero)
+     * @returns The integer quotient as an Int
+     *
+     * @example
+     * ```typescript
+     * // Positive division
+     * Int.div(asInt(10), asInt(3));   // Int (3)
+     * Int.div(asInt(9), asInt(3));    // Int (3)
+     *
+     * // Negative division (rounds toward -∞)
+     * Int.div(asInt(-10), asInt(3));  // Int (-4)
+     * Int.div(asInt(10), asInt(-3));  // Int (-4)
+     * Int.div(asInt(-10), asInt(-3)); // Int (3)
+     * ```
+     */
+    div,
+};
+
+export { Int, asInt, isInt };
+//# sourceMappingURL=int.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAgClE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}