valgen 5.2.2 → 5.3.1

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'.
@@ -6,7 +6,8 @@ import { validator } from '../core/index.js';
  */
 export function isInteger(options) {
     return validator('isInteger', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
@@ -17,6 +18,7 @@ export function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.fail(_this, `{{label}} must be an integer number`, input);
+        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/type-rules/is-null.js

@@ -0,0 +1,29 @@
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is "null".
+ * @validator isNull
+ */
+export function isNull(options) {
+    return validator('isNull', function (input, context, _this) {
+        if (input === null)
+            return input;
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
+            return null;
+        context.fail(_this, `"{{value}}" is not null`, input);
+    }, options);
+}
+/**
+ * Validates if value is "null" or "undefined".
+ * @validator isNull
+ */
+export function isNullish(options) {
+    return validator('isNullish', function (input, context, _this) {
+        if (input == null)
+            return input;
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
+            return null;
+        context.fail(_this, `"{{value}}" is not nullish`, 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'.
@@ -6,17 +6,19 @@ import { validator } from '../core/index.js';
  */
 export function isNumber(options) {
     return validator('isNumber', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
                 const v = Number(input);
                 if (input === BigInt(v))
-                    input = v;
+                    return v;
             }
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.fail(_this, `{{label}} must be a number`, input);
+        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'.
@@ -34,7 +34,8 @@ export function isObject(schema, options) {
     const _rule = validator('isObject', function (input, context, _this) {
         if (ctor && ctor[preValidation])
             input = ctor[preValidation](input, context, _this);
-        if (typeof input === 'string' && context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (typeof input === 'string' && coerce)
             input = JSON.parse(input);
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
@@ -65,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'.
@@ -6,7 +6,8 @@ import { validator } from '../core/index.js';
  */
 export function isString(options) {
     return validator('isString', function (input, context, _this) {
-        if (input != null && typeof input !== 'string' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'string' && coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
                     input = input.toJSON();

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

@@ -1,10 +1,11 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 export function isTuple(items, options) {
     return validator('isTuple', function (input, context, _this) {
-        if (input != null && context.coerce && !Array.isArray(input))
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} must be a tuple`, input);
+            context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
         }
         const location = context.location || '';
@@ -21,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 {
@@ -27,6 +27,6 @@ export function union(codecs) {
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `{{location}} didn't match any of required format`, input);
+        context.fail(_this, `Value didn't match any on union rules`, input);
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.2.2",
+  "version": "5.3.1",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -14,7 +14,7 @@
   "dependencies": {
     "@types/validator": "^13.11.9",
     "date-fns": "^3.6.0",
-    "ts-gems": "^3.2.1",
+    "ts-gems": "^3.4.0",
     "validator": "^13.11.0"
   },
   "type": "module",

package/typings/core/types.d.ts

@@ -14,6 +14,7 @@ export interface ErrorIssue {
 export type OnFailFunction = (issue: ErrorIssue, context: Context, _super?: OnFailFunction) => string | Omit<ErrorIssue, 'id' | 'input'>;
 export interface ValidationOptions {
     onFail?: OnFailFunction;
+    coerce?: boolean;
 }
 export interface ExecutionOptions extends ValidationOptions {
     coerce?: boolean;

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,5 +49,12 @@ 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>;
-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 };
+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>;
+declare const toDateString: import("./core/validator.js").Validator<string, string | number | Date, import("./core/types.js").ExecutionOptions>;
+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, 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>;

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

@@ -0,0 +1,9 @@
+import * as validatorJS from 'validator';
+import { ValidationOptions } from '../../core/index.js';
+export interface Base64ValidatorOptions extends ValidationOptions, validatorJS.IsBase64Options {
+}
+/**
+ * Validates if value is a "Base64" string.
+ * @validator isBase64
+ */
+export declare function isBase64(options?: Base64ValidatorOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-btc-address.d.ts

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is a BTC address.
+ * @validator isBtcAddress
+ */
+export declare function isBtcAddress(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-credit-card.d.ts

@@ -0,0 +1,9 @@
+import * as validatorJS from 'validator';
+import { ValidationOptions } from '../../core/index.js';
+export interface CreditCardValidatorOptions extends ValidationOptions, validatorJS.IsCreditCardOptions {
+}
+/**
+ * Validates if value is a credit card number
+ * @validator isCreditCard
+ */
+export declare function isCreditCard(options?: CreditCardValidatorOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,7 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Check if the string represents a decimal number,
+ * such as `0.1`, `.3`, `1.1`, `1.00003`, `4.0` etc.
+ * @validator isDecimal
+ */
+export declare function isDecimal(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is an EAN (European Article Number)
+ * @validator isEAN
+ */
+export declare function isEAN(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,62 @@
+import { ValidationOptions } from '../../core/index.js';
+export interface IsEmailOptions extends ValidationOptions {
+    /**
+     * If set to `true`, the validator will also match `Display Name <email-address>`.
+     *
+     * @default false
+     */
+    allowDisplayName?: boolean;
+    /**
+     * If set to `true`, the validator will reject strings without the format `Display Name <email-address>`.
+     *
+     * @default false
+     */
+    requireDisplayName?: boolean;
+    /**
+     * If set to `false`, the validator will not allow any non-English UTF8 character in email address' local part.
+     *
+     * @default true
+     */
+    utf8LocalPart?: boolean;
+    /**
+     * If set to `true`, the validator will not check for the standard max length of an email.
+     *
+     * @default false
+     */
+    ignoreMaxLength?: boolean;
+    /**
+     * If set to `true`, the validator will allow IP addresses in the host part.
+     *
+     * @default false
+     */
+    allowIpDomain?: boolean;
+    /**
+     * If set to `true`, some additional validation will be enabled,
+     * e.g. disallowing certain syntactically valid email addresses that are rejected by GMail.
+     *
+     * @default false
+     */
+    domainSpecificValidation?: boolean;
+    /**
+     *  If set to an array of strings and the part of the email after
+     *  the @ symbol matches one of the strings defined in it,
+     *  the validation fails.
+     */
+    hostBlacklist?: string[];
+    /**
+     * If set to an array of strings and the part of the email after
+     * the @ symbol matches none of the strings defined in it,
+     * the validation fails.
+     */
+    hostWhitelist?: string[];
+    /**
+     *  If set to a string, then the validator will reject emails that include
+     *  any of the characters in the string, in the name part.
+     */
+    blacklistedChars?: string;
+}
+/**
+ * Validates if value is a valid Email
+ * @validator isEmail
+ */
+export declare function isEmail(options?: IsEmailOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-eth-address.d.ts

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is a ETH (Ethereum) address.
+ * @validator isETHAddress
+ */
+export declare function isETHAddress(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,13 @@
+import { ValidationOptions } from '../../core/index.js';
+export interface IsFQDNOptions extends ValidationOptions {
+    /**
+     * If set to true, the validator will allow domain starting with `*.` (e.g. `*.example.com` or `*.shop.example.com`).
+     * @default false
+     */
+    allowWildcard?: boolean;
+}
+/**
+ * Validates if value is an FQDN
+ * @validator isFQDN
+ */
+export declare function isFQDN(options?: IsFQDNOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,8 @@
+import * as validatorJS from 'validator';
+import { ValidationOptions } from '../../core/index.js';
+export type HashAlgorithm = validatorJS.HashAlgorithm;
+/**
+ * Validates if value a hash of type algorithm
+ * @validator isHash
+ */
+export declare function isHash(algorithm: HashAlgorithm, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-hex-color.d.ts

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is a Hex Color
+ * @validator isHexColor
+ */
+export declare function isHexColor(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Check if the string is a hexadecimal number.
+ * @validator isHex
+ */
+export declare function isHex(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,11 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is an IBAN (International Bank Account Number)
+ * @validator isIBAN
+ */
+export declare function isIBAN(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isSWIFT
+ */
+export declare function isSWIFT(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,11 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is an IP
+ * @validator isIP
+ */
+export declare function isIP(version?: 4 | 6, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an IP
+ * @validator isIPRange
+ */
+export declare function isIPRange(version?: 4 | 6, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,14 @@
+import { ValidationOptions } from '../../core/index.js';
+export interface IsISSNOptions extends ValidationOptions {
+    /**
+     * If set to `true`, ISSNs with a lowercase `x` as the check digit are rejected.
+     *
+     * @default false
+     */
+    caseSensitive?: boolean;
+}
+/**
+ * Validates if value is an ISSN
+ * @validator isISSN
+ */
+export declare function isISSN(options?: IsISSNOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,6 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value a valid JWT token
+ * @validator isJWT
+ */
+export declare function isJWT(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -0,0 +1,11 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value a Lowercase string
+ * @validator isLowercase
+ */
+export declare function isLowercase(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value a Uppercase string
+ * @validator isUppercase
+ */
+export declare function isUppercase(options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/typings/rules/format-rules/is-mac-address.d.ts

@@ -0,0 +1,21 @@
+import { ValidationOptions } from '../../core/index.js';
+export interface IsMACAddressOptions extends ValidationOptions {
+    /**
+     * If set to `true`, the validator will allow MAC addresses without the colons.
+     * Also, it allows the use of hyphens or spaces.
+     *
+     * e.g. `01 02 03 04 05 ab` or `01-02-03-04-05-ab`.
+     *
+     * @default false
+     */
+    noSeparators?: boolean;
+    /**
+     * Setting `eui` allows for validation against EUI-48 or EUI-64 instead of both.
+     */
+    eui?: '48' | '64';
+}
+/**
+ * Validates if value is an MACAddress
+ * @validator isMACAddress
+ */
+export declare function isMACAddress(options?: IsMACAddressOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;