valgen 5.3.0 → 5.3.2

package/esm/rules/index.js

@@ -1,22 +1,49 @@
-export * from './is-any.js';
-export * from './is-array.js';
-export * from './is-bigint.js';
-export * from './is-boolean.js';
-export * from './is-date.js';
-export * from './is-empty.js';
-export * from './is-enum.js';
-export * from './is-integer.js';
-export * from './is-null.js';
-export * from './is-regexp.js';
-export * from './is-number.js';
-export * from './is-object.js';
-export * from './is-object-id.js';
-export * from './is-record.js';
-export * from './is-string.js';
-export * from './is-tuple.js';
-export * from './length.js';
-export * from './optional.js';
-export * from './pipe.js';
-export * from './range.js';
-export * from './string-formats.js';
-export * from './union.js';
+export * from './type-rules/is-any.js';
+export * from './type-rules/is-array.js';
+export * from './type-rules/is-bigint.js';
+export * from './type-rules/is-boolean.js';
+export * from './type-rules/is-date.js';
+export * from './type-rules/is-enum.js';
+export * from './type-rules/is-integer.js';
+export * from './type-rules/is-null.js';
+export * from './type-rules/is-number.js';
+export * from './type-rules/is-object.js';
+export * from './type-rules/is-record.js';
+export * from './type-rules/is-string.js';
+export * from './type-rules/is-tuple.js';
+export * from './format-rules/is-alpha.js';
+export * from './format-rules/is-ascii.js';
+export * from './format-rules/is-base64.js';
+export * from './format-rules/is-btc-address.js';
+export * from './format-rules/is-credit-card.js';
+export * from './format-rules/is-decimal.js';
+export * from './format-rules/is-ean.js';
+export * from './format-rules/is-email.js';
+export * from './format-rules/is-eth-address.js';
+export * from './format-rules/is-fqdn.js';
+export * from './format-rules/is-hash.js';
+export * from './format-rules/is-hex.js';
+export * from './format-rules/is-hex-color.js';
+export * from './format-rules/is-iban.js';
+export * from './format-rules/is-ip.js';
+export * from './format-rules/is-issn.js';
+export * from './format-rules/is-jwt.js';
+export * from './format-rules/is-lowercase.js';
+export * from './format-rules/is-mac-address.js';
+export * from './format-rules/is-mobile-phone.js';
+export * from './format-rules/is-object-id.js';
+export * from './format-rules/is-passport-number.js';
+export * from './format-rules/is-port.js';
+export * from './format-rules/is-url.js';
+export * from './format-rules/is-uuid.js';
+export * from './format-rules/is-vat-number.js';
+export * from './format-rules/matches.js';
+export * from './logical-rules/is-defined.js';
+export * from './logical-rules/is-empty.js';
+export * from './logical-rules/range.js';
+export * from './utility-rules/exists.js';
+export * from './utility-rules/get-length.js';
+export * from './utility-rules/optional.js';
+export * from './utility-rules/pipe.js';
+export * from './utility-rules/required.js';
+export * from './utility-rules/union.js';

package/esm/rules/logical-rules/is-defined.js

@@ -0,0 +1,25 @@
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is not "undefined" nor "null"
+ * @validator isDefined
+ */
+export function isDefined(options) {
+    return validator('is-defined', function (input, context, _this) {
+        if (input !== undefined)
+            return input;
+        context.fail(_this, `Is not defined`, input);
+    }, options);
+}
+/**
+ * Validates if value is "undefined"
+ * @validator isUndefined
+ */
+export function isUndefined(options) {
+    return validator('isUndefined', function (input, context, _this) {
+        if (options?.coerce || context.coerce)
+            return undefined;
+        if (input === undefined)
+            return;
+        context.fail(_this, `{{label}} mustn\'t be defined`, input);
+    }, options);
+}

package/esm/rules/{is-empty.js → logical-rules/is-empty.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Checks if value is an empty. Value should be string, array, set, map or object
  * @validator isEmpty

package/esm/rules/{range.js → logical-rules/range.js}

@@ -1,4 +1,33 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
+import { getLength } from '../utility-rules/get-length.js';
+import { allOf, pipe } from '../utility-rules/pipe.js';
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+export function range(minValue, maxValue, options) {
+    return validator('range', function (input, context, _this) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        if (minValue instanceof Date &&
+            maxValue instanceof Date &&
+            input instanceof Date &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        if (typeof minValue === 'string' &&
+            typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
+    }, options);
+}
 export function isGt(minValue, options) {
     return validator('isGt', function (input, context, _this) {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
@@ -7,11 +36,11 @@ export function isGt(minValue, options) {
             return input;
         if (minValue instanceof Date && input instanceof Date && input > minValue)
             return input;
-        if (typeof minValue === 'string' && typeof input === 'string' &&
-            (input > minValue ||
-                (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
+        if (typeof minValue === 'string' &&
+            typeof input === 'string' &&
+            (input > minValue || (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
+        context.fail(_this, `{{label}} must be greater than ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isGte(minValue, options) {
@@ -22,11 +51,11 @@ export function isGte(minValue, options) {
             return input;
         if (minValue instanceof Date && input instanceof Date && input >= minValue)
             return input;
-        if (typeof minValue === 'string' && typeof input === 'string' &&
-            (input >= minValue ||
-                (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
+        if (typeof minValue === 'string' &&
+            typeof input === 'string' &&
+            (input >= minValue || (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
+        context.fail(_this, `{{label}} must be greater than or equal to ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isLt(maxValue, options) {
@@ -37,45 +66,39 @@ export function isLt(maxValue, options) {
             return input;
         if (maxValue instanceof Date && input instanceof Date && input < maxValue)
             return input;
-        if (typeof maxValue === 'string' && typeof input === 'string' &&
-            (input < maxValue ||
-                (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
+        if (typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            (input < maxValue || (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
+        context.fail(_this, `{{label}} must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
 export function isLte(maxValue, options) {
-    return validator('isLt', function (input, context, _this) {
+    return validator('isLte', function (input, context, _this) {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue)
             return input;
         if (maxValue instanceof Date && input instanceof Date && input <= maxValue)
             return input;
-        if (typeof maxValue === 'string' && typeof input === 'string' &&
-            (input <= maxValue ||
-                (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
+        if (typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            (input <= maxValue || (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
+        context.fail(_this, `{{label}} must be lover than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
 /**
- * Checks if value is between minValue and maxValue
- * @validator range
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
  */
-export function range(minValue, maxValue, options) {
-    return validator('range', function (input, context, _this) {
-        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
-            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
-            (typeof input === 'number' || typeof input === 'bigint') &&
-            input >= minValue && input <= maxValue)
-            return input;
-        if (minValue instanceof Date && maxValue instanceof Date &&
-            input instanceof Date && input >= minValue && input <= maxValue)
-            return input;
-        if (typeof minValue === 'string' && typeof maxValue === 'string' &&
-            typeof input === 'string' && input >= minValue && input <= maxValue)
-            return input;
-        context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
-    }, options);
-}
+export const lengthMin = (minValue) => allOf(pipe(getLength(), isGte(minValue, {
+    onFail: () => `The length of {{label}} must be at least ${minValue}`,
+})));
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator lengthMax
+ */
+export const lengthMax = (maxValue) => allOf(pipe(getLength(), isLte(maxValue, {
+    onFail: () => `The length of {{label}} must be at most ${maxValue}`,
+})));

package/esm/rules/{is-any.js → type-rules/is-any.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Does nothing, just returns original input value.
  * @validator isAny

package/esm/rules/{is-array.js → type-rules/is-array.js}

@@ -1,4 +1,4 @@
-import { validator, } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "array" and applies validation for each item.
  * Converts input value to array if coerce option is set to 'true'.
@@ -25,9 +25,7 @@ export function isArray(itemValidator, options) {
             v = input[i];
             itemContext.scope = input;
             // itemContext.location = location + '[' + i + ']';
-            itemContext.location = context.location
-                ? context.location + `[${i}]`
-                : `<Array>[${i}]`;
+            itemContext.location = context.location ? context.location + `[${i}]` : `<Array>[${i}]`;
             itemContext.index = i;
             v = itemValidator(v, itemContext);
             out.push(v);

package/esm/rules/{is-bigint.js → type-rules/is-bigint.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "BigInt".
  * Converts input value to number if coerce option is set to 'true'.
@@ -9,8 +9,7 @@ export function isBigint(options) {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'bigint')
             return input;
-        if ((typeof input === 'number' && !isNaN(input)) ||
-            (typeof input === 'string' && coerce))
+        if ((typeof input === 'number' && !isNaN(input)) || (typeof input === 'string' && coerce))
             return BigInt(input);
         const t = typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid BigInt value`, input);

package/esm/rules/{is-boolean.js → type-rules/is-boolean.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 const TRUE_PATTERN = /^true|t|1|yes|y$/i;
 const FALSE_PATTERN = /^false|f|0|no|n$/i;
 /**

package/esm/rules/{is-date.js → type-rules/is-date.js}

@@ -1,7 +1,9 @@
 import { formatISO, parseISO } from 'date-fns';
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /* eslint-disable-next-line max-len */ // noinspection RegExpUnnecessaryNonCapturingGroup
-const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,3}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
+const DATE_PATTERN = 
+// eslint-disable-next-line max-len
+/^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,3}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
 /**
  * Validates if value is instance of "Date".
  * Converts input value to Date if coerce option is set to 'true'.
@@ -81,9 +83,7 @@ export function isDateString(options) {
             }
         }
         else if (input instanceof Date) {
-            return trim === 'date'
-                ? formatISO(input, { representation: 'date' })
-                : formatISO(input).substring(0, 19);
+            return trim === 'date' ? formatISO(input, { representation: 'date' }) : formatISO(input).substring(0, 19);
         }
         context.fail(_this, `"{{value}}" is not a valid date string`, input, { ...options });
     }, options);

package/esm/rules/{is-enum.js → type-rules/is-enum.js}

@@ -1,14 +1,13 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if given value is one of enum values.
  * @validator isEnum
  */
 export function isEnum(values, options) {
-    const caseInSensitive = !!(options?.caseInSensitive);
+    const caseInSensitive = !!options?.caseInSensitive;
     const enumName = options?.enumName;
     // Prepare an object for fast lookup
-    const valObj = (Array.isArray(values) ? values : [values])
-        .reduce((a, v) => {
+    const valObj = (Array.isArray(values) ? values : [values]).reduce((a, v) => {
         if (typeof v === 'string' && caseInSensitive)
             a[v.toUpperCase()] = true;
         else
@@ -18,6 +17,8 @@ export function isEnum(values, options) {
     return validator('isEnum', function (input, context, _this) {
         if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
             return input;
-        context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, { enum: enumName });
+        context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, {
+            enum: enumName,
+        });
     }, options);
 }

package/esm/rules/{is-integer.js → type-rules/is-integer.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "integer".
  * Converts input value to integer number if coerce option is set to 'true'.
@@ -18,8 +18,7 @@ export function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        const t = typeof input === 'bigint' ? 'BigInt ' :
-            (typeof input === 'string' ? 'String ' : '');
+        const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);
 }

package/esm/rules/{is-null.js → type-rules/is-null.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "null".
  * @validator isNull
@@ -27,27 +27,3 @@ export function isNullish(options) {
         context.fail(_this, `"{{value}}" is not nullish`, input);
     }, options);
 }
-/**
- * Validates if value is not "undefined" nor "null"
- * @validator isDefined
- */
-export function isDefined(options) {
-    return validator('is-defined', function (input, context, _this) {
-        if (input !== undefined)
-            return input;
-        context.fail(_this, `Is not defined`, input);
-    }, options);
-}
-/**
- * Validates if value is "undefined"
- * @validator isUndefined
- */
-export function isUndefined(options) {
-    return validator('isUndefined', function (input, context, _this) {
-        if (options?.coerce || context.coerce)
-            return undefined;
-        if (input === undefined)
-            return;
-        context.fail(_this, `{{label}} mustn\'t be defined`, input);
-    }, options);
-}

package/esm/rules/{is-number.js → type-rules/is-number.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "number".
  * Converts input value to number if coerce option is set to 'true'.
@@ -18,8 +18,7 @@ export function isNumber(options) {
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        const t = typeof input === 'bigint' ? 'BigInt ' :
-            (typeof input === 'string' ? 'String ' : '');
+        const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);
 }

package/esm/rules/{is-object.js → type-rules/is-object.js}

@@ -1,5 +1,5 @@
-import { postValidation, preValidation } from '../constants.js';
-import { isValidator, validator } from '../core/index.js';
+import { postValidation, preValidation } from '../../constants.js';
+import { isValidator, validator, } from '../../core/index.js';
 /**
  * Validates object according to schema
  * Converts properties according to schema rules if coerce option is set to 'true'.
@@ -66,8 +66,7 @@ export function isObject(schema, options) {
             inputKey = keys[i];
             schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
             v = input[inputKey];
-            _propRule = propertyRules[schemaKey] ||
-                (isValidator(additionalFields) ? additionalFields : undefined);
+            _propRule = propertyRules[schemaKey] || (isValidator(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;

package/esm/rules/{is-record.js → type-rules/is-record.js}

@@ -1,4 +1,4 @@
-import { validator, } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.

package/esm/rules/{is-string.js → type-rules/is-string.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "string".
  * Converts input value to string if coerce option is set to 'true'.

package/esm/rules/{is-tuple.js → type-rules/is-tuple.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 export function isTuple(items, options) {
     return validator('isTuple', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
@@ -22,8 +22,7 @@ export function isTuple(items, options) {
             itemContext.label = context.label ? context.label + `[${i}]` : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
-            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') +
-                `[${i}]`;
+            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
             v = itemRule(input[i], itemContext);
             out.push(v);
         }

package/esm/rules/utility-rules/exists.js

@@ -0,0 +1,12 @@
+import { validator } from '../../core/index.js';
+/**
+ * Validates if property exists
+ * @validator exists
+ */
+export function exists(options) {
+    return validator('exists', function (input, context, _this) {
+        if (input !== undefined || (context.scope && Object.getOwnPropertyDescriptor(context.scope, input)))
+            return input;
+        context.fail(_this, `{{label}} must exist`, input);
+    }, options);
+}

package/esm/rules/utility-rules/get-length.js

@@ -0,0 +1,20 @@
+import { validator } from '../../core/index.js';
+/**
+ * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * @validator getLength
+ */
+export function getLength() {
+    return validator('getLength', function (input, context, _this) {
+        if (typeof input === 'string')
+            return input.length;
+        if (Array.isArray(input))
+            return input.length;
+        if (input instanceof ArrayBuffer)
+            return input.byteLength;
+        if (input && typeof input === 'object' && typeof input.length === 'number')
+            return input.length;
+        if (input && typeof input === 'object' && typeof input.size === 'number')
+            return input.size;
+        context.fail(_this, `Unable to get length of {{label}}`, input);
+    });
+}

package/esm/rules/utility-rules/optional.js

@@ -0,0 +1,12 @@
+import { validator } from '../../core/index.js';
+/**
+ * Makes sub-rule optional
+ * @validator optional
+ */
+export function optional(nested, options) {
+    return validator('optional', function (input, context) {
+        if (input == null)
+            return input;
+        return nested(input, context);
+    }, options);
+}

package/esm/rules/{pipe.js → utility-rules/pipe.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  *
  * @validator pipe

package/esm/rules/utility-rules/required.js

@@ -0,0 +1,14 @@
+import { validator } from '../../core/index.js';
+/**
+ * Makes sub-rule required
+ * @validator required
+ */
+export function required(nested, options) {
+    return validator('required', function (input, context, _this) {
+        if (input == null) {
+            context.fail(_this, `{{label}} is required`, input);
+            return;
+        }
+        return nested(input, context);
+    }, options);
+}

package/esm/rules/{union.js → utility-rules/union.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  *
  */
@@ -10,7 +10,7 @@ export function union(codecs) {
         let v;
         let passed = false;
         // Mock fail method to prevent errors
-        context.fail = () => passed = false;
+        context.fail = () => (passed = false);
         for (i = 0; i < l; i++) {
             c = codecs[i];
             try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -12,10 +12,10 @@
     "url": "https://github.com/panates/valgen.git"
   },
   "dependencies": {
-    "@types/validator": "^13.11.9",
+    "@types/validator": "^13.11.10",
     "date-fns": "^3.6.0",
     "ts-gems": "^3.4.0",
-    "validator": "^13.11.0"
+    "validator": "^13.12.0"
   },
   "type": "module",
   "types": "typings/index.d.ts",

package/typings/index.d.ts

@@ -1,7 +1,7 @@
 import * as vg from './rules/index.js';
 export * from './constants.js';
 export * from './core/index.js';
-export { IsObject } from './rules/is-object.js';
+export { IsObject } from './rules/type-rules/is-object.js';
 declare const isAny: import("./core/validator.js").Validator<any, any, import("./core/types.js").ExecutionOptions>;
 declare const isArray: import("./core/validator.js").Validator<unknown[], unknown, import("./core/types.js").ExecutionOptions>;
 declare const isBigint: import("./core/validator.js").Validator<bigint, unknown, import("./core/types.js").ExecutionOptions>;
@@ -33,7 +33,7 @@ declare const isMACAddress: import("./core/validator.js").Validator<string, stri
 declare const isPort: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isURL: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isBase64: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
-declare const isBIC: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
+declare const isSWIFT: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isCreditCard: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isIBAN: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isEAN: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
@@ -49,7 +49,7 @@ declare const isAlpha: import("./core/validator.js").Validator<string, string, i
 declare const isAlphanumeric: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isAscii: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isDecimal: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
-declare const isHexadecimal: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
+declare const isHex: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const toArray: import("./core/validator.js").Validator<any[], any, import("./core/types.js").ExecutionOptions>;
 declare const toBoolean: import("./core/validator.js").Validator<boolean | undefined, unknown, import("./core/types.js").ExecutionOptions>;
 declare const toDate: import("./core/validator.js").Validator<Date, string | number | Date, import("./core/types.js").ExecutionOptions>;
@@ -57,4 +57,4 @@ declare const toDateString: import("./core/validator.js").Validator<string, stri
 declare const toInteger: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
 declare const toNumber: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
 declare const toString: import("./core/validator.js").Validator<string, unknown, import("./core/types.js").ExecutionOptions>;
-export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal, toArray, toBoolean, toDate, toDateString, toInteger, toNumber, toString };
+export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isSWIFT, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHex, toArray, toBoolean, toDate, toDateString, toInteger, toNumber, toString, };

package/typings/rules/format-rules/is-alpha.d.ts

@@ -0,0 +1,11 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Check if the string contains only letters (a-zA-Z).
+ * @validator isAlpha
+ */
+export declare function isAlpha(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Check if the string contains only letters and numbers.
+ * @validator isAlphanumeric
+ */
+export declare function isAlphanumeric(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-ascii.d.ts

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Check if the string contains ASCII chars only.
+ * @validator isAscii
+ */
+export declare function isAscii(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;