valgen 5.19.5 → 6.0.0

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '5.19.5';
+export const version = '6.0.0';
 export const postValidation = Symbol('postValidation');
 export const preValidation = Symbol('preValidation');
 export const VALIDATE_METADATA = Symbol('VALIDATE_METADATA');

package/index.d.ts

@@ -1,10 +1,7 @@
 import { Context, ExecutionOptions } from './core/index.js';
-import { DatePrecision } from './rules/index.js';
 import * as vg from './rules/index.js';
 export * from './constants.js';
 export * from './core/index.js';
-export type { DatePrecision } from './rules/type-rules/is-date.js';
-export type { IsObject } from './rules/type-rules/is-object.js';
 declare const isAlpha: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const isAlphanumeric: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const isAny: import("./core/validator.js").Validator<any, any, ExecutionOptions>;
@@ -41,8 +38,8 @@ declare const isNotNullish: import("./core/validator.js").Validator<unknown, unk
 declare const isNull: import("./core/validator.js").Validator<null, unknown, ExecutionOptions>;
 declare const isNullish: import("./core/validator.js").Validator<null, unknown, ExecutionOptions>;
 declare const isNumber: import("./core/validator.js").Validator<number, unknown, ExecutionOptions>;
-declare const isObject: vg.IsObject.Validator<object, string | object>;
-declare const isObjectId: import("./core/validator.js").Validator<string | vg.ObjectIdLike | Uint8Array<ArrayBufferLike>, unknown, ExecutionOptions>;
+declare const isObject: vg.isObject.Validator<object, string | object>;
+declare const isObjectId: import("./core/validator.js").Validator<string | Uint8Array<ArrayBufferLike> | vg.isObjectId.ObjectIdLike, unknown, ExecutionOptions>;
 declare const isPort: import("./core/validator.js").Validator<number, string | number, ExecutionOptions>;
 declare const isString: import("./core/validator.js").Validator<string, unknown, ExecutionOptions>;
 declare const isSWIFT: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
@@ -56,15 +53,18 @@ declare const isUUID2: import("./core/validator.js").Validator<string, string, E
 declare const isUUID3: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const isUUID4: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const isUUID5: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
+declare const isUUID6: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
+declare const isUUID7: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
+declare const isUUID8: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const toArray: import("./core/validator.js").Validator<any[], any, ExecutionOptions>;
 declare const toBigint: import("./core/validator.js").Validator<bigint, unknown, ExecutionOptions>;
 declare const toBoolean: import("./core/validator.js").Validator<boolean | undefined, unknown, ExecutionOptions>;
 declare const toDate: import("./core/validator.js").Validator<Date, string | number | Date, ExecutionOptions>;
 declare const toDateString: (input: Date | string | number, options?: ExecutionOptions & {
-    trim?: DatePrecision;
+    trim?: vg.isDateString.Precision;
 }, ctx?: Context) => any;
 declare const toInteger: import("./core/validator.js").Validator<number, unknown, ExecutionOptions>;
 declare const toNumber: import("./core/validator.js").Validator<number, unknown, ExecutionOptions>;
 declare const toString: import("./core/validator.js").Validator<string, unknown, ExecutionOptions>;
 declare const toTime: import("./core/validator.js").Validator<string, string | Date, ExecutionOptions>;
-export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNotNull, isNotNullish, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isTime, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, toTime, vg, };
+export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNotNull, isNotNullish, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isTime, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isUUID6, isUUID7, isUUID8, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, toTime, vg, };

package/index.js

@@ -52,21 +52,24 @@ const isUUID2 = vg.isUUID(2);
 const isUUID3 = vg.isUUID(3);
 const isUUID4 = vg.isUUID(4);
 const isUUID5 = vg.isUUID(5);
+const isUUID6 = vg.isUUID(6);
+const isUUID7 = vg.isUUID(7);
+const isUUID8 = vg.isUUID(8);
 const toArray = vg.isArray(isAny, { coerce: true });
 const toBigint = vg.isBigint({ coerce: true });
 const toBoolean = vg.isBoolean({ coerce: true });
 const toDate = vg.isDate({ coerce: true });
 const toDateStringValidators = new Map();
 const toDateString = (input, options, ctx) => {
-    const trim = options?.trim ?? 'ms';
-    let validator = toDateStringValidators.get(trim);
+    const precisionMax = options?.trim ?? 'ms';
+    let validator = toDateStringValidators.get(precisionMax);
     if (!validator) {
         validator = vg.isDateString({
             coerce: true,
-            precisionMax: trim,
+            precisionMax,
             trim: true,
         });
-        toDateStringValidators.set(trim, validator);
+        toDateStringValidators.set(precisionMax, validator);
     }
     return validator(input, options, ctx);
 };
@@ -74,4 +77,4 @@ const toInteger = vg.isInteger({ coerce: true });
 const toNumber = vg.isNumber({ coerce: true });
 const toString = vg.isString({ coerce: true });
 const toTime = vg.isTime({ coerce: true });
-export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNotNull, isNotNullish, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isTime, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, toTime, vg, };
+export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNotNull, isNotNullish, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isTime, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isUUID6, isUUID7, isUUID8, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, toTime, vg, };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.19.5",
+  "version": "6.0.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
-    "@browsery/validator": "^13.15.15",
+    "@browsery/validator": "^13.15.35",
     "date-fns": "^4.1.0",
     "reflect-metadata": "^0.2.2",
-    "ts-gems": "^3.11.3",
+    "ts-gems": "^3.11.6",
     "tslib": "^2.8.1"
   },
   "type": "module",

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

@@ -3,9 +3,8 @@ import { type 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>;
+export declare function isAlpha(options?: isAlpha.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isAlpha {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/format-rules/is-alpha.js

@@ -5,21 +5,9 @@ import { validator, } from '../../core/index.js';
  * @validator isAlpha
  */
 export function isAlpha(options) {
-    return validator('isLowercase', (input, context, _this) => {
+    return validator('isAlpha', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAlpha(input))
             return input;
         context.fail(_this, `"Value must be an alpha string`, input);
     }, options);
 }
-/**
- * Check if the string contains only letters and numbers.
- * @validator isAlphanumeric
- */
-export function isAlphanumeric(options) {
-    return validator('isAlphanumeric', (input, context, _this) => {
-        if (typeof input === 'string' && validatorJS.isAlphanumeric(input)) {
-            return input;
-        }
-        context.fail(_this, `"Value must be an alphanumeric string`, input);
-    }, options);
-}

package/rules/format-rules/is-alphanumeric.d.ts

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

package/rules/format-rules/is-alphanumeric.js

@@ -0,0 +1,14 @@
+import validatorJS from '@browsery/validator';
+import { validator, } from '../../core/index.js';
+/**
+ * Check if the string contains only letters and numbers.
+ * @validator isAlphanumeric
+ */
+export function isAlphanumeric(options) {
+    return validator('isAlphanumeric', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isAlphanumeric(input)) {
+            return input;
+        }
+        context.fail(_this, `"Value must be an alphanumeric string`, input);
+    }, options);
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isAscii(options?: isAscii.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isAscii {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -1,9 +1,11 @@
-import validatorJS from '@browsery/validator';
+import { type IsBase64Options as _IsBase64Options } from '@browsery/validator';
 import { type 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>;
+export declare function isBase64(options?: isBase64.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isBase64 {
+    interface Options extends ValidationOptions, _IsBase64Options {
+    }
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isBtcAddress(options?: isBtcAddress.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isBtcAddress {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -1,9 +1,11 @@
-import validatorJS from '@browsery/validator';
+import { type IsCreditCardOptions as _IsCreditCardOptions } from '@browsery/validator';
 import { type 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>;
+export declare function isCreditCard(options?: isCreditCard.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isCreditCard {
+    interface Options extends ValidationOptions, _IsCreditCardOptions {
+    }
+}

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

@@ -4,4 +4,8 @@ import { type ValidationOptions } from '../../core/index.js';
  * 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>;
+export declare function isDecimal(options?: isDecimal.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isDecimal {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isEAN(options?: isEAN.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isEAN {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -1,62 +1,64 @@
 import { type 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>;
+export declare function isEmail(options?: isEmail.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isEmail {
+    interface Options 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;
+    }
+}

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

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

package/rules/format-rules/is-eth-address.js

@@ -1,7 +1,7 @@
 import validatorJS from '@browsery/validator';
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is a ETH (Ethereum) address.
+ * Validates if value is an ETH (Ethereum) address.
  * @validator isETHAddress
  */
 export function isETHAddress(options) {

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

@@ -1,13 +1,15 @@
 import { type 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>;
+export declare function isFQDN(options?: isFQDN.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isFQDN {
+    interface Options 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;
+    }
+}

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

@@ -1,8 +1,10 @@
-import validatorJS from '@browsery/validator';
+import { type HashAlgorithm as _HashAlgorithm } from '@browsery/validator';
 import { type 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>;
+export declare function isHash(algorithm: isHash.HashAlgorithm, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isHash {
+    type HashAlgorithm = _HashAlgorithm;
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isHexColor(options?: isHexColor.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isHexColor {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isHex(options?: isHex.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isHex {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -3,9 +3,8 @@ import { type 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>;
+export declare function isIBAN(options?: isIBAN.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isIBAN {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/format-rules/is-iban.js

@@ -11,14 +11,3 @@ export function isIBAN(options) {
         context.fail(_this, `Value must be a valid IBAN (International Bank Account Number)`, input);
     }, options);
 }
-/**
- * Validates if value is a BIC (Bank Identification Code) or SWIFT code
- * @validator isSWIFT
- */
-export function isSWIFT(options) {
-    return validator('isSWIFT', (input, context, _this) => {
-        if (typeof input === 'string' && validatorJS.isBIC(input))
-            return input;
-        context.fail(_this, `Value must be a valid a BIC (Bank Identification Code) or SWIFT code`, input);
-    }, options);
-}

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

@@ -1,11 +1,18 @@
+import { type IPVersion as _IPVersion } from '@browsery/validator';
 import { type 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>;
+export declare function isIP(version?: isIP.IPVersion, 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>;
+export declare function isIPRange(version?: isIPRange.IPVersion, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isIP {
+    type IPVersion = _IPVersion;
+}
+export declare namespace isIPRange {
+    type IPVersion = _IPVersion;
+}

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

@@ -1,14 +1,16 @@
 import { type 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>;
+export declare function isISSN(options?: isISSN.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isISSN {
+    interface Options extends ValidationOptions {
+        /**
+         * If set to `true`, ISSNs with a lowercase `x` as the check digit are rejected.
+         *
+         * @default false
+         */
+        caseSensitive?: boolean;
+    }
+}

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

@@ -3,4 +3,8 @@ import { type 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>;
+export declare function isJWT(options?: isJWT.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isJWT {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -3,9 +3,8 @@ import { type 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>;
+export declare function isLowercase(options?: isLowercase.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isLowercase {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/format-rules/is-lowercase.js

@@ -12,15 +12,3 @@ export function isLowercase(options) {
         context.fail(_this, `Value must be a lowercase string`, input);
     }, options);
 }
-/**
- * Validates if value a Uppercase string
- * @validator isUppercase
- */
-export function isUppercase(options) {
-    return validator('isUppercase', (input, context, _this) => {
-        if (typeof input === 'string' && validatorJS.isUppercase(input)) {
-            return input;
-        }
-        context.fail(_this, `Value must be an uppercase string`, input);
-    }, options);
-}

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

@@ -1,21 +1,23 @@
 import { type 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>;
+export declare function isMACAddress(options?: isMACAddress.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isMACAddress {
+    interface Options 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';
+    }
+}