ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,128 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-zero integer';
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    nonZero: true,
+    MIN_VALUE: undefined,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a NonZeroInt.
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroInt, `false` otherwise.
+ */
+const isNonZeroInt = is;
+/**
+ * Casts a number to a NonZeroInt type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroInt type.
+ * @throws {TypeError} If the value is not a non-zero integer.
+ * @example
+ * ```typescript
+ * const x = asNonZeroInt(5); // NonZeroInt
+ * const y = asNonZeroInt(-3); // NonZeroInt
+ * // asNonZeroInt(0); // throws TypeError
+ * // asNonZeroInt(1.5); // throws TypeError
+ * ```
+ */
+const asNonZeroInt = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for non-zero integers.
+ *
+ * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
+ * Division operations return floor division results, and all arithmetic maintains integer precision.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonZeroInt(10);
+ * const b = asNonZeroInt(-5);
+ *
+ * // Arithmetic operations
+ * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
+ * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
+ * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
+ * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
+ *
+ * // Utility operations
+ * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
+ * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
+ * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
+ * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
+ *
+ * // Random generation
+ * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
+ * ```
+ */
+const NonZeroInt = {
+    /**
+     * Type guard to check if a value is a NonZeroInt.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-zero integer, `false` otherwise.
+     */
+    is,
+    /**
+     * Returns the absolute value of a non-zero integer.
+     * @param a The non-zero integer.
+     * @returns The absolute value as a NonZeroInt.
+     */
+    abs,
+    /**
+     * Returns the smaller of two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns The minimum value as a NonZeroInt.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns The maximum value as a NonZeroInt.
+     */
+    max: max_,
+    /**
+     * Generates a random non-zero integer.
+     * @returns A random NonZeroInt value.
+     */
+    random,
+    /**
+     * Raises a non-zero integer to the power of another non-zero integer.
+     * @param a The base non-zero integer.
+     * @param b The exponent non-zero integer.
+     * @returns `a ** b` as a NonZeroInt.
+     */
+    pow,
+    /**
+     * Adds two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns `a + b` as a NonZeroInt.
+     */
+    add,
+    /**
+     * Subtracts one non-zero integer from another.
+     * @param a The minuend non-zero integer.
+     * @param b The subtrahend non-zero integer.
+     * @returns `a - b` as a NonZeroInt.
+     */
+    sub,
+    /**
+     * Multiplies two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns `a * b` as a NonZeroInt.
+     */
+    mul,
+    /**
+     * Divides one non-zero integer by another using floor division.
+     * @param a The dividend non-zero integer.
+     * @param b The divisor non-zero integer.
+     * @returns `⌊a / b⌋` as a NonZeroInt.
+     */
+    div,
+};
+
+export { NonZeroInt, asNonZeroInt, isNonZeroInt };
+//# sourceMappingURL=non-zero-int.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,UAAU,GAAG;AACxB;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;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-zero-int16.d.mts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAiClE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;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"}

package/dist/number/branded-types/non-zero-int16.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-int16.mjs","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;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-zero-int32.d.mts

@@ -0,0 +1,158 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+/**
+ * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the range [-2^31, 2^31) excluding 0).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroInt32, `false` otherwise.
+ */
+export declare const isNonZeroInt32: (a: number) => a is NonZeroInt32;
+/**
+ * Casts a number to a NonZeroInt32 type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroInt32 type.
+ * @throws {TypeError} If the value is not a non-zero integer in [-2^31, 2^31).
+ * @example
+ * ```typescript
+ * const x = asNonZeroInt32(1000); // NonZeroInt32
+ * const y = asNonZeroInt32(-1000); // NonZeroInt32
+ * // asNonZeroInt32(0); // throws TypeError
+ * // asNonZeroInt32(2147483648); // throws TypeError
+ * ```
+ */
+export declare const asNonZeroInt32: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^31": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly SafeInt: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit non-zero signed integers.
+ *
+ * All operations automatically clamp results to the valid NonZeroInt32 range [-2147483648, 2147483647]
+ * excluding 0. This ensures that all arithmetic maintains the 32-bit non-zero signed integer
+ * constraint, preventing zero results and overflow.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonZeroInt32(2000000000);
+ * const b = asNonZeroInt32(-500000000);
+ *
+ * // Arithmetic operations with automatic clamping and non-zero constraint
+ * const sum = NonZeroInt32.add(a, b);       // NonZeroInt32 (1500000000)
+ * const diff = NonZeroInt32.sub(a, b);      // NonZeroInt32 (2147483647 - clamped to MAX_VALUE)
+ * const product = NonZeroInt32.mul(a, b);   // NonZeroInt32 (-2147483648 - clamped to MIN_VALUE)
+ *
+ * // Utility operations
+ * const absolute = NonZeroInt32.abs(b);         // NonZeroInt32 (500000000)
+ * const minimum = NonZeroInt32.min(a, b);       // NonZeroInt32 (-500000000)
+ * const maximum = NonZeroInt32.max(a, b);       // NonZeroInt32 (2000000000)
+ *
+ * // Range operations (avoiding zero)
+ * const clamped = NonZeroInt32.clamp(0);        // NonZeroInt32 (1 or -1, avoiding zero)
+ * const random = NonZeroInt32.random();         // NonZeroInt32 (random non-zero value in range)
+ * const power = NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(20)); // NonZeroInt32 (1048576)
+ * ```
+ */
+export declare const NonZeroInt32: {
+    /**
+     * Type guard to check if a value is a NonZeroInt32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit non-zero signed integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonZeroInt32;
+    /**
+     * The minimum value for a 32-bit non-zero signed integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: number;
+    /**
+     * The maximum value for a 32-bit non-zero signed integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the absolute value of a 32-bit non-zero signed integer.
+     * @param a The NonZeroInt32 value.
+     * @returns The absolute value as a NonZeroInt32, clamped to valid range.
+     */
+    readonly abs: (x: WithSmallInt<NonZeroInt32, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt32>;
+    /**
+     * Returns the smaller of two NonZeroInt32 values.
+     * @param a The first NonZeroInt32.
+     * @param b The second NonZeroInt32.
+     * @returns The minimum value as a NonZeroInt32.
+     */
+    readonly min: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
+    /**
+     * Returns the larger of two NonZeroInt32 values.
+     * @param a The first NonZeroInt32.
+     * @param b The second NonZeroInt32.
+     * @returns The maximum value as a NonZeroInt32.
+     */
+    readonly max: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
+    /**
+     * Clamps a number to the NonZeroInt32 range (avoiding zero).
+     * @param value The number to clamp.
+     * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a NonZeroInt32.
+     */
+    readonly clamp: (x: number) => NonZeroInt32;
+    /**
+     * Generates a random NonZeroInt32 value within the valid range.
+     * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding 0).
+     */
+    readonly random: (min: WithSmallInt<NonZeroInt32, 40>, max: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    /**
+     * Raises a NonZeroInt32 to the power of another NonZeroInt32.
+     * @param a The base NonZeroInt32.
+     * @param b The exponent NonZeroInt32.
+     * @returns `a ** b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
+     */
+    readonly pow: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    /**
+     * Adds two NonZeroInt32 values.
+     * @param a The first NonZeroInt32.
+     * @param b The second NonZeroInt32.
+     * @returns `a + b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
+     */
+    readonly add: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    /**
+     * Subtracts one NonZeroInt32 from another.
+     * @param a The minuend NonZeroInt32.
+     * @param b The subtrahend NonZeroInt32.
+     * @returns `a - b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
+     */
+    readonly sub: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    /**
+     * Multiplies two NonZeroInt32 values.
+     * @param a The first NonZeroInt32.
+     * @param b The second NonZeroInt32.
+     * @returns `a * b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
+     */
+    readonly mul: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    /**
+     * Divides one NonZeroInt32 by another using floor division.
+     * @param a The dividend NonZeroInt32.
+     * @param b The divisor NonZeroInt32.
+     * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
+     */
+    readonly div: (x: WithSmallInt<NonZeroInt32, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -24 | -14 | -34 | -12 | -13 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -25 | -26 | -27 | -28 | -29 | -30 | -31 | -33 | -35 | -36 | -37 | -38 | -39 | -40 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly "> -2^32": true;
+        readonly ">= -2^31": true;
+        readonly "< 2^31": true;
+        readonly "< 2^32": true;
+        readonly Finite: true;
+        readonly Int: true;
+        readonly SafeInt: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => NonZeroInt32;
+};
+//# sourceMappingURL=non-zero-int32.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAiClE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;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"}