ts-fortress 2.4.0 → 2.6.0

package/README.md

@@ -71,11 +71,9 @@ if (User.is(userData)) {
     console.log(`User: ${userData.name}, Age: ${userData.age}`);
 }
 
-import { Result } from 'ts-data-forge';
-
 // Get validation result with error details
 const result = User.validate(userData);
-if (Result.isOk(result)) {
+if (t.Result.isOk(result)) {
     const user = result.value; // typed as User
 } else {
     console.error('Validation errors:', result.value); // readonly ValidationError[] showing error information
@@ -132,7 +130,7 @@ const completeUser: UserProfile = UserProfile.fill(anyPartialData);
 // The is() and validate() functions can still detect missing keys
 console.log(UserProfile.is(partialData)); // false - missing required keys
 const result = UserProfile.validate(partialData);
-if (Result.isErr(result)) {
+if (t.Result.isErr(result)) {
     console.log(result.value); // ValidationError[] showing missing keys
 }
 ```
@@ -413,7 +411,7 @@ const C = t.partial(
     const UnionBA = t.union([B, A]);
     const result = UnionBA.validate({ A: 1 });
 
-    if (Result.isOk(result)) {
+    if (t.Result.isOk(result)) {
         console.log(result.value); // { A: 1 } <- ✅ Correct! No unexpected fields
         console.log(A.is(result.value)); // true  <- ✅ Correct
         console.log(B.is(result.value)); // false <- ✅ Correct! B requires field B
@@ -425,7 +423,7 @@ const C = t.partial(
     const UnionCA = t.union([C, A]);
     const result = UnionCA.validate({ A: 1 });
 
-    if (Result.isOk(result)) {
+    if (t.Result.isOk(result)) {
         console.log(result.value); // { A: 1 } <- ✅ Correct and consistent
         console.log(A.is(result.value)); // true  <- ✅ Correct
         console.log(C.is(result.value)); // true  <- ✅ Consistent! ts-fortress partial types allow extra fields
@@ -496,7 +494,6 @@ The `validate` method performs comprehensive validation and returns a `Result` t
 
 ```typescript
 import * as t from 'ts-fortress';
-import { Result } from 'ts-data-forge';
 
 const User = t.record({
     name: t.string(''),
@@ -507,7 +504,7 @@ const User = t.record({
 const validData = { name: 'Alice', age: 30 };
 const result = User.validate(validData);
 
-if (Result.isOk(result)) {
+if (t.Result.isOk(result)) {
     console.log(result.value === validData); // true - same reference!
     console.log(result.value); // { name: 'Alice', age: 30 }
 }
@@ -516,7 +513,7 @@ if (Result.isOk(result)) {
 const invalidData = { name: 'Bob', age: 'thirty' };
 const errorResult = User.validate(invalidData);
 
-if (Result.isErr(errorResult)) {
+if (t.Result.isErr(errorResult)) {
     console.log(errorResult.value);
     // [
     //   {
@@ -749,7 +746,7 @@ const UInt16 = t.uint16(0);
 
 // Usage
 const userIdResult = UserId.validate('user_123');
-if (Result.isOk(userIdResult)) {
+if (t.Result.isOk(userIdResult)) {
     const id: UserId = userIdResult.value;
 }
 ```
@@ -815,7 +812,7 @@ const UserType = t.record({
 const invalidData = { name: 123, age: 'not a number' };
 
 const result = UserType.validate(invalidData);
-if (Result.isErr(result)) {
+if (t.Result.isErr(result)) {
     // result.value is an array of ValidationError objects
     for (const error of result.value) {
         console.log('Path:', error.path); // ['name'] or ['age']
@@ -851,7 +848,7 @@ const StrictType = t.record(
 const dataWithExcess = { name: 'John', age: 30, extra: 'not allowed' };
 const strictResult = StrictType.validate(dataWithExcess);
 
-if (Result.isErr(strictResult)) {
+if (t.Result.isErr(strictResult)) {
     console.log(strictResult.value);
     // [{
     //   path: ['extra'],

package/dist/entry-point.d.mts

@@ -0,0 +1,3 @@
+export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8, } from 'ts-data-forge';
+export * from './index.mjs';
+//# sourceMappingURL=entry-point.d.mts.map

package/dist/entry-point.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,GAAG,EACH,KAAK,EACL,KAAK,EACL,IAAI,EACJ,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,aAAa,EACb,eAAe,EACf,cAAc,EACd,cAAc,EACd,MAAM,EACN,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,MAAM,EACN,KAAK,EACL,cAAc,EACd,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,yBAAyB,EACzB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,cAAc,EACd,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,yBAAyB,EACzB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,OAAO,GACR,MAAM,eAAe,CAAC;AACvB,cAAc,aAAa,CAAC"}

package/dist/entry-point.mjs

@@ -0,0 +1,56 @@
+export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8 } from 'ts-data-forge';
+export { arrayOfLength } from './array/array-of-length.mjs';
+export { array } from './array/array.mjs';
+export { nonEmptyArray } from './array/non-empty-array.mjs';
+export { tuple } from './array/tuple.mjs';
+export { brand } from './branded/brand.mjs';
+export { finiteNumber } from './branded/number/finite-number.mjs';
+export { int } from './branded/number/int.mjs';
+export { int16 } from './branded/number/int16.mjs';
+export { int32 } from './branded/number/int32.mjs';
+export { nonNegativeFiniteNumber } from './branded/number/non-negative-finite-number.mjs';
+export { nonZeroFiniteNumber } from './branded/number/non-zero-finite-number.mjs';
+export { nonZeroInt } from './branded/number/non-zero-int.mjs';
+export { nonZeroSafeInt } from './branded/number/non-zero-safe-int.mjs';
+export { positiveFiniteNumber } from './branded/number/positive-finite-number.mjs';
+export { positiveInt } from './branded/number/positive-int.mjs';
+export { positiveSafeInt } from './branded/number/positive-safe-int.mjs';
+export { safeInt } from './branded/number/safe-int.mjs';
+export { safeUint } from './branded/number/safe-uint.mjs';
+export { uint } from './branded/number/uint.mjs';
+export { uint16 } from './branded/number/uint16.mjs';
+export { uint32 } from './branded/number/uint32.mjs';
+export { simpleBrandedNumber } from './branded/simple-branded-number.mjs';
+export { simpleBrandedString } from './branded/simple-branded-string.mjs';
+export { intersection } from './compose/intersection.mjs';
+export { mergeRecords } from './compose/merge-records.mjs';
+export { recursion } from './compose/recursion.mjs';
+export { union } from './compose/union.mjs';
+export { enumType } from './enum/enum.mjs';
+export { intRange } from './enum/int-range.mjs';
+export { uintRange } from './enum/uint-range.mjs';
+export { int8 } from './predefined/int8.mjs';
+export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
+export { uint8 } from './predefined/uint8.mjs';
+export { bigint, bigintLiteral } from './primitives/bigint.mjs';
+export { boolean, booleanLiteral } from './primitives/boolean.mjs';
+export { nullType } from './primitives/null.mjs';
+export { number, numberLiteral } from './primitives/number.mjs';
+export { string, stringLiteral } from './primitives/string.mjs';
+export { symbol } from './primitives/symbol.mjs';
+export { undefinedType } from './primitives/undefined.mjs';
+export { keyValueRecord } from './record/key-value-record.mjs';
+export { keyof } from './record/keyof.mjs';
+export { omit } from './record/omit.mjs';
+export { isOptionalProperty, optional } from './record/optional.mjs';
+export { partial } from './record/partial.mjs';
+export { pick } from './record/pick.mjs';
+export { record, strictRecord } from './record/record.mjs';
+export { unknown } from './unknown.mjs';
+export { createAssertFn } from './utils/create-assert-fn.mjs';
+export { createCastFn } from './utils/create-cast-fn.mjs';
+export { createIsFn } from './utils/create-is-fn.mjs';
+export { createPrimitiveType } from './utils/create-primitive-type.mjs';
+export { createType } from './utils/create-type.mjs';
+export { createPrimitiveValidationError, prependIndexToValidationErrors, prependPathToValidationErrors, validationErrorToMessage, validationErrorsToMessages } from './utils/validation-error.mjs';
+//# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/enum/index.d.mts

@@ -1,3 +1,4 @@
 export * from './enum.mjs';
+export * from './int-range.mjs';
 export * from './uint-range.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/enum/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/enum/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/enum/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dist/enum/index.mjs

@@ -1,3 +1,4 @@
 export { enumType } from './enum.mjs';
+export { intRange } from './int-range.mjs';
 export { uintRange } from './uint-range.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/enum/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/enum/int-range.d.mts

@@ -0,0 +1,13 @@
+import { type Type } from '../type.mjs';
+export declare const intRange: <Start extends Int8 | -128, End extends Int8 | 128>({ start, end, ...options }: Readonly<{
+    typeName?: string;
+    start: Start;
+    end: End;
+    defaultValue?: IntRange<Start, End>;
+}>) => Type<IntRange<Start, End>>;
+type NegativeRange = NegativeIndex<128>;
+type PositiveRange = IndexInclusive<128>;
+type IntRange<Start extends Int8 | -128, End extends Int8 | 128> = BoolAnd<TypeExtends<Start, PositiveRange>, TypeExtends<End, PositiveRange>> extends true ? UintRange<Start, End> : BoolAnd<TypeExtends<Start, NegativeRange>, TypeExtends<End, PositiveRange>> extends true ? NegativeIndex<NegativeToPositive<Start>> | Index<End> : BoolAnd<TypeExtends<Start, PositiveRange>, TypeExtends<End, NegativeRange>> extends true ? never : BoolAnd<TypeExtends<Start, NegativeRange>, TypeExtends<End, NegativeRange>> extends true ? Exclude<NegativeIndex<NegativeToPositive<Start>>, NegativeIndex<NegativeToPositive<End>>> : never;
+type NegativeToPositive<N extends number> = `${N}` extends `-${infer D extends number}` ? D : never;
+export {};
+//# sourceMappingURL=int-range.d.mts.map

package/dist/enum/int-range.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"int-range.d.mts","sourceRoot":"","sources":["../../src/enum/int-range.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,EAAE,GAAG,SAAS,IAAI,GAAG,GAAG,EAAE,4BAIzE,QAAQ,CAAC;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,YAAY,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;CACrC,CAAC,KAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAwC7B,CAAC;AAEF,KAAK,aAAa,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;AACxC,KAAK,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;AAEzC,KAAK,QAAQ,CAAC,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,EAAE,GAAG,SAAS,IAAI,GAAG,GAAG,IAC7D,OAAO,CACL,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,EACjC,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,CAChC,SAAS,IAAI,GACV,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,GACrB,OAAO,CACH,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,EACjC,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,CAChC,SAAS,IAAI,GACd,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GACrD,OAAO,CACH,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,EACjC,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,CAChC,SAAS,IAAI,GACd,KAAK,GACL,OAAO,CACH,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,EACjC,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,CAChC,SAAS,IAAI,GACd,OAAO,CACL,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EACxC,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CACvC,GACD,KAAK,CAAC;AAElB,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,IACtC,GAAG,CAAC,EAAE,SAAS,IAAI,MAAM,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/enum/int-range.mjs

@@ -0,0 +1,40 @@
+import { isNumber, Num, Result } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+
+const intRange = ({ start, end, ...options }) => {
+    const typeNameFilled = options.typeName ?? `intRange(${start}, ${end})`;
+    const defaultValue = options.defaultValue ??
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        start;
+    const validate = (a) => {
+        if (!(isNumber(a) && Number.isInteger(a) && Num.isInRange(start, end)(a))) {
+            return Result.err([
+                {
+                    path: [],
+                    actualValue: a,
+                    expectedType: typeNameFilled,
+                    message: `The value is expected to be an integer between ${start} and ${end - 1}`,
+                    typeName: typeNameFilled,
+                },
+            ]);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return Result.ok(a);
+    };
+    const is = createIsFn(validate);
+    const fill = (a) => (is(a) ? a : defaultValue);
+    return {
+        typeName: typeNameFilled,
+        defaultValue,
+        fill,
+        validate,
+        is,
+        assertIs: createAssertFn(validate),
+        cast: createCastFn(validate),
+    };
+};
+
+export { intRange };
+//# sourceMappingURL=int-range.mjs.map

package/dist/enum/int-range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"int-range.mjs","sources":["../../src/enum/int-range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AASO,MAAM,QAAQ,GAAG,CAAoD,EAC1E,KAAK,EACL,GAAG,EACH,GAAG,OAAO,EAMV,KAAgC;IAGhC,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,IAAI,CAAA,SAAA,EAAY,KAAK,CAAA,EAAA,EAAK,GAAG,CAAA,CAAA,CAAG;AAEvE,IAAA,MAAM,YAAY,GAChB,OAAO,CAAC,YAAY;;AAEnB,QAAA,KAAW;AAEd,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAI;QAC1C,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;YACzE,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA;AACE,oBAAA,IAAI,EAAE,EAAE;AACR,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,cAAc;AAC5B,oBAAA,OAAO,EAAE,CAAA,+CAAA,EAAkD,KAAK,QAAQ,GAAG,GAAG,CAAC,CAAA,CAAE;AACjF,oBAAA,QAAQ,EAAE,cAAc;AACY,iBAAA;AACvC,aAAA,CAAC;;;AAIJ,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAM,CAAC;AAC1B,IAAA,CAAC;AAED,IAAA,MAAM,EAAE,GAAG,UAAU,CAAI,QAAQ,CAAC;IAElC,MAAM,IAAI,GAAoB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC;IAE/D,OAAO;AACL,QAAA,QAAQ,EAAE,cAAc;QACxB,YAAY;QACZ,IAAI;QACJ,QAAQ;QACR,EAAE;AACF,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;AAClC,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;KAC7B;AACH;;;;"}

package/dist/enum/uint-range.d.mts

@@ -1,5 +1,5 @@
 import { type Type } from '../type.mjs';
-export declare const uintRange: <Start extends Uint8, End extends Exclude<Uint8, Start>>({ start, end, ...options }: Readonly<{
+export declare const uintRange: <Start extends Uint8, End extends Exclude<Uint8 | 256, Start>>({ start, end, ...options }: Readonly<{
     typeName?: string;
     start: Start;
     end: End;

package/dist/enum/uint-range.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uint-range.d.mts","sourceRoot":"","sources":["../../src/enum/uint-range.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,SAAS,GACpB,KAAK,SAAS,KAAK,EACnB,GAAG,SAAS,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EACjC,4BAIC,QAAQ,CAAC;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,YAAY,CAAC,EAAE,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;CACtC,CAAC,KAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAwC9B,CAAC"}
+{"version":3,"file":"uint-range.d.mts","sourceRoot":"","sources":["../../src/enum/uint-range.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,SAAS,GACpB,KAAK,SAAS,KAAK,EACnB,GAAG,SAAS,OAAO,CAAC,KAAK,GAAG,GAAG,EAAE,KAAK,CAAC,EACvC,4BAIC,QAAQ,CAAC;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,YAAY,CAAC,EAAE,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;CACtC,CAAC,KAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAwC9B,CAAC"}

package/dist/index.mjs

@@ -26,8 +26,11 @@ export { mergeRecords } from './compose/merge-records.mjs';
 export { recursion } from './compose/recursion.mjs';
 export { union } from './compose/union.mjs';
 export { enumType } from './enum/enum.mjs';
+export { intRange } from './enum/int-range.mjs';
 export { uintRange } from './enum/uint-range.mjs';
+export { int8 } from './predefined/int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
+export { uint8 } from './predefined/uint8.mjs';
 export { bigint, bigintLiteral } from './primitives/bigint.mjs';
 export { boolean, booleanLiteral } from './primitives/boolean.mjs';
 export { nullType } from './primitives/null.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/predefined/index.d.mts

@@ -1,2 +1,4 @@
+export * from './int8.mjs';
 export * from './json.mjs';
+export * from './uint8.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/predefined/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/predefined/index.mjs

@@ -1,2 +1,4 @@
+export { int8 } from './int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './json.mjs';
+export { uint8 } from './uint8.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/predefined/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/predefined/int8.d.mts

@@ -0,0 +1,3 @@
+import { type Type } from '../type.mjs';
+export declare const int8: (defaultValue?: Int8) => Type<Int8>;
+//# sourceMappingURL=int8.d.mts.map

package/dist/predefined/int8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../src/predefined/int8.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,eAAO,MAAM,IAAI,GAAI,eAAc,IAAQ,KAAG,IAAI,CAAC,IAAI,CAKnD,CAAC"}

package/dist/predefined/int8.mjs

@@ -0,0 +1,11 @@
+import 'ts-data-forge';
+import { intRange } from '../enum/int-range.mjs';
+
+const int8 = (defaultValue = 0) => intRange({
+    start: -128,
+    end: 128,
+    defaultValue,
+});
+
+export { int8 };
+//# sourceMappingURL=int8.mjs.map

package/dist/predefined/int8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"int8.mjs","sources":["../../src/predefined/int8.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGO,MAAM,IAAI,GAAG,CAAC,YAAA,GAAqB,CAAC,KACzC,QAAQ,CAAC;IACP,KAAK,EAAE,IAAI;AACX,IAAA,GAAG,EAAE,GAAG;IACR,YAAY;AACb,CAAA;;;;"}

package/dist/predefined/uint8.d.mts

@@ -0,0 +1,3 @@
+import { type Type } from '../type.mjs';
+export declare const uint8: (defaultValue?: Uint8) => Type<Uint8>;
+//# sourceMappingURL=uint8.d.mts.map

package/dist/predefined/uint8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../src/predefined/uint8.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,eAAO,MAAM,KAAK,GAAI,eAAc,KAAS,KAAG,IAAI,CAAC,KAAK,CAKtD,CAAC"}

package/dist/predefined/uint8.mjs

@@ -0,0 +1,11 @@
+import 'ts-data-forge';
+import { uintRange } from '../enum/uint-range.mjs';
+
+const uint8 = (defaultValue = 0) => uintRange({
+    start: 0,
+    end: 256,
+    defaultValue,
+});
+
+export { uint8 };
+//# sourceMappingURL=uint8.mjs.map

package/dist/predefined/uint8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8.mjs","sources":["../../src/predefined/uint8.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGO,MAAM,KAAK,GAAG,CAAC,YAAA,GAAsB,CAAC,KAC3C,SAAS,CAAC;AACR,IAAA,KAAK,EAAE,CAAC;AACR,IAAA,GAAG,EAAE,GAAG;IACR,YAAY;AACb,CAAA;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -17,11 +17,11 @@
     ".": {
       "import": {
         "types": "./dist/types.d.mts",
-        "default": "./dist/index.mjs"
+        "default": "./dist/entry-point.mjs"
       }
     }
   },
-  "module": "./dist/index.mjs",
+  "module": "./dist/entry-point.mjs",
   "types": "./dist/types.d.mts",
   "files": [
     "src",
@@ -37,7 +37,7 @@
     "doc": "tsx ./scripts/cmd/gen-docs.mjs",
     "fmt": "format-diff-from origin/main",
     "fmt:full": "prettier --write .",
-    "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'",
+    "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --fmt 'npm run fmt'",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "md": "markdownlint-cli2",
@@ -57,7 +57,7 @@
     "ts-type-forge": "^2.2.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.33.0",
+    "@eslint/js": "^9.34.0",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-strip": "^3.0.4",
     "@rollup/plugin-typescript": "^12.1.4",
@@ -73,7 +73,7 @@
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "cspell": "^9.2.0",
-    "eslint": "^9.33.0",
+    "eslint": "^9.34.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-array-func": "5.0.2",
     "eslint-plugin-functional": "9.0.2",
@@ -89,7 +89,7 @@
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.2.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.46.2",
+    "rollup": "^4.48.0",
     "semantic-release": "^24.2.7",
     "ts-repo-utils": "^6.0.3",
     "tslib": "^2.8.1",
@@ -97,8 +97,8 @@
     "typedoc": "^0.28.10",
     "typedoc-plugin-markdown": "^4.8.1",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.39.1",
+    "typescript-eslint": "^8.40.0",
     "vitest": "^3.2.4",
-    "zod": "^4.0.17"
+    "zod": "^4.1.0"
   }
 }

package/src/entry-point.mts

@@ -0,0 +1,89 @@
+export {
+  FiniteNumber,
+  Int,
+  Int16,
+  Int32,
+  Int8,
+  NonNegativeFiniteNumber,
+  NonNegativeInt16,
+  NonNegativeInt32,
+  NonZeroFiniteNumber,
+  NonZeroInt,
+  NonZeroInt16,
+  NonZeroInt32,
+  NonZeroSafeInt,
+  NonZeroUint16,
+  NonZeroUint32,
+  PositiveFiniteNumber,
+  PositiveInt,
+  PositiveInt16,
+  PositiveInt32,
+  PositiveSafeInt,
+  PositiveUint16,
+  PositiveUint32,
+  Result,
+  SafeInt,
+  SafeUint,
+  Uint,
+  Uint16,
+  Uint32,
+  Uint8,
+  asFiniteNumber,
+  asInt,
+  asInt16,
+  asInt32,
+  asInt8,
+  asNonNegativeFiniteNumber,
+  asNonNegativeInt16,
+  asNonNegativeInt32,
+  asNonZeroFiniteNumber,
+  asNonZeroInt,
+  asNonZeroInt16,
+  asNonZeroInt32,
+  asNonZeroSafeInt,
+  asNonZeroUint16,
+  asNonZeroUint32,
+  asPositiveFiniteNumber,
+  asPositiveInt,
+  asPositiveInt16,
+  asPositiveInt32,
+  asPositiveSafeInt,
+  asPositiveUint16,
+  asPositiveUint32,
+  asSafeInt,
+  asSafeUint,
+  asUint,
+  asUint16,
+  asUint32,
+  asUint8,
+  isBigint,
+  isFiniteNumber,
+  isInt,
+  isInt16,
+  isInt32,
+  isInt8,
+  isNonNegativeFiniteNumber,
+  isNonNegativeInt16,
+  isNonNegativeInt32,
+  isNonZeroFiniteNumber,
+  isNonZeroInt,
+  isNonZeroInt16,
+  isNonZeroInt32,
+  isNonZeroSafeInt,
+  isNonZeroUint16,
+  isNonZeroUint32,
+  isPositiveFiniteNumber,
+  isPositiveInt,
+  isPositiveInt16,
+  isPositiveInt32,
+  isPositiveSafeInt,
+  isPositiveUint16,
+  isPositiveUint32,
+  isSafeInt,
+  isSafeUint,
+  isUint,
+  isUint16,
+  isUint32,
+  isUint8,
+} from 'ts-data-forge';
+export * from './index.mjs';

package/src/enum/index.mts

@@ -1,2 +1,3 @@
 export * from './enum.mjs';
+export * from './int-range.mjs';
 export * from './uint-range.mjs';

package/src/enum/int-range.mts

@@ -0,0 +1,98 @@
+import { expectType, isNumber, Num, Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
+
+export const intRange = <Start extends Int8 | -128, End extends Int8 | 128>({
+  start,
+  end,
+  ...options
+}: Readonly<{
+  typeName?: string;
+  start: Start;
+  end: End;
+  defaultValue?: IntRange<Start, End>;
+}>): Type<IntRange<Start, End>> => {
+  type T = IntRange<Start, End>;
+
+  const typeNameFilled = options.typeName ?? `intRange(${start}, ${end})`;
+
+  const defaultValue: T =
+    options.defaultValue ??
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    (start as T);
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!(isNumber(a) && Number.isInteger(a) && Num.isInRange(start, end)(a))) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeNameFilled,
+          message: `The value is expected to be an integer between ${start} and ${end - 1}`,
+          typeName: typeNameFilled,
+        } satisfies ValidationErrorWithMessage,
+      ]);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.ok(a as T);
+  };
+
+  const is = createIsFn<T>(validate);
+
+  const fill: Type<T>['fill'] = (a) => (is(a) ? a : defaultValue);
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type NegativeRange = NegativeIndex<128>;
+type PositiveRange = IndexInclusive<128>;
+
+type IntRange<Start extends Int8 | -128, End extends Int8 | 128> =
+  BoolAnd<
+    TypeExtends<Start, PositiveRange>,
+    TypeExtends<End, PositiveRange>
+  > extends true
+    ? UintRange<Start, End>
+    : BoolAnd<
+          TypeExtends<Start, NegativeRange>,
+          TypeExtends<End, PositiveRange>
+        > extends true
+      ? NegativeIndex<NegativeToPositive<Start>> | Index<End>
+      : BoolAnd<
+            TypeExtends<Start, PositiveRange>,
+            TypeExtends<End, NegativeRange>
+          > extends true
+        ? never
+        : BoolAnd<
+              TypeExtends<Start, NegativeRange>,
+              TypeExtends<End, NegativeRange>
+            > extends true
+          ? Exclude<
+              NegativeIndex<NegativeToPositive<Start>>,
+              NegativeIndex<NegativeToPositive<End>>
+            >
+          : never;
+
+type NegativeToPositive<N extends number> =
+  `${N}` extends `-${infer D extends number}` ? D : never;
+
+expectType<NegativeToPositive<-3>, 3>('=');
+
+expectType<IntRange<1, 5>, 1 | 2 | 3 | 4>('=');
+expectType<IntRange<-3, 3>, -3 | -2 | -1 | 0 | 1 | 2>('=');
+expectType<IntRange<3, -3>, never>('=');
+expectType<IntRange<-5, -1>, -5 | -4 | -3 | -2>('=');

package/src/enum/uint-range.mts

@@ -9,7 +9,7 @@ import {
 
 export const uintRange = <
   Start extends Uint8,
-  End extends Exclude<Uint8, Start>,
+  End extends Exclude<Uint8 | 256, Start>,
 >({
   start,
   end,

package/src/predefined/index.mts

@@ -1 +1,3 @@
+export * from './int8.mjs';
 export * from './json.mjs';
+export * from './uint8.mjs';

package/src/predefined/int8.mts

@@ -0,0 +1,9 @@
+import { intRange } from '../enum/index.mjs';
+import { type Type } from '../type.mjs';
+
+export const int8 = (defaultValue: Int8 = 0): Type<Int8> =>
+  intRange({
+    start: -128,
+    end: 128,
+    defaultValue,
+  });

package/src/predefined/uint8.mts

@@ -0,0 +1,9 @@
+import { uintRange } from '../enum/index.mjs';
+import { type Type } from '../type.mjs';
+
+export const uint8 = (defaultValue: Uint8 = 0): Type<Uint8> =>
+  uintRange({
+    start: 0,
+    end: 256,
+    defaultValue,
+  });