valgen 5.19.5 → 6.0.0

package/rules/format-rules/is-mobile-phone.d.ts

@@ -1,20 +1,22 @@
-import validatorJS from '@browsery/validator';
+import { type MobilePhoneLocale as _MobilePhoneLocale } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
-export interface IsMobilePhoneOptions extends ValidationOptions {
-    /**
-     * If this is set to `true`, the mobile phone number must be supplied with the country code and therefore must start with `+`.
-     *
-     * @default false
-     */
-    strictMode?: boolean;
-    /**
-     * Locale or locales of the mobile phone
-     * @default 'any'
-     */
-    locale?: 'any' | validatorJS.MobilePhoneLocale | validatorJS.MobilePhoneLocale[];
-}
 /**
  * Validates if value is a valid Email
  * @validator isMobilePhone
  */
-export declare function isMobilePhone(options?: IsMobilePhoneOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function isMobilePhone(options?: isMobilePhone.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isMobilePhone {
+    interface Options extends ValidationOptions {
+        /**
+         * If this is set to `true`, the mobile phone number must be supplied with the country code and therefore must start with `+`.
+         *
+         * @default false
+         */
+        strictMode?: boolean;
+        /**
+         * Locale or locales of the mobile phone
+         * @default 'any'
+         */
+        locale?: 'any' | _MobilePhoneLocale | _MobilePhoneLocale[];
+    }
+}

package/rules/format-rules/is-object-id.d.ts

@@ -1,10 +1,12 @@
 import { type ValidationOptions } from '../../core/index.js';
-export declare interface ObjectIdLike {
-    id: string | Uint8Array;
-    toHexString(): string;
-}
 /**
  * Validates if value is an "ObjectId".
  * @validator isObjectId
  */
-export declare function isObjectId(options?: ValidationOptions): import("../../core/validator.js").Validator<string | ObjectIdLike | Uint8Array<ArrayBufferLike>, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare function isObjectId(options?: ValidationOptions): import("../../core/validator.js").Validator<string | Uint8Array<ArrayBufferLike> | isObjectId.ObjectIdLike, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isObjectId {
+    interface ObjectIdLike {
+        id: string | Uint8Array;
+        toHexString(): string;
+    }
+}

package/rules/format-rules/is-passport-number.d.ts

@@ -3,4 +3,8 @@ import { type ValidationOptions } from '../../core/index.js';
  * Validates if value is a passport number
  * @validator isPassportNumber
  */
-export declare function isPassportNumber(countryCode: string, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function isPassportNumber(countryCode: string, options?: isPassportNumber.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isPassportNumber {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -3,4 +3,8 @@ import { type ValidationOptions } from '../../core/index.js';
  * Validates if value is a port number
  * @validator isPort
  */
-export declare function isPort(options?: ValidationOptions): import("../../core/validator.js").Validator<number, string | number, import("../../core/types.js").ExecutionOptions>;
+export declare function isPort(options?: isPort.Options): import("../../core/validator.js").Validator<number, string | number, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isPort {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -0,0 +1,10 @@
+import { type ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isSWIFT
+ */
+export declare function isSWIFT(options?: isSWIFT.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isSWIFT {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -0,0 +1,13 @@
+import validatorJS from '@browsery/validator';
+import { validator, } from '../../core/index.js';
+/**
+ * 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-time.d.ts

@@ -1,8 +1,10 @@
 import { type ValidationOptions } from '../../core/index.js';
-export interface IsTimeOptions extends ValidationOptions {
-}
 /**
  * Validates if value is a time formatted string
  * @validator isTime
  */
-export declare function isTime(options?: IsTimeOptions): import("../../core/validator.js").Validator<string, string | Date, import("../../core/types.js").ExecutionOptions>;
+export declare function isTime(options?: isTime.Options): import("../../core/validator.js").Validator<string, string | Date, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isTime {
+    interface Options extends ValidationOptions {
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+import validatorJS from '@browsery/validator';
+import { validator, } from '../../core/index.js';
+/**
+ * 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-url.d.ts

@@ -1,9 +1,11 @@
-import validatorJS from '@browsery/validator';
+import { type IsURLOptions as _IsURLOptions } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
-export interface IsURLOptions extends ValidationOptions, validatorJS.IsURLOptions {
-}
 /**
  * Validates if value is an URL
  * @validator isURL
  */
-export declare function isURL(options?: IsURLOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function isURL(options?: isURL.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isURL {
+    interface Options extends ValidationOptions, _IsURLOptions {
+    }
+}

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

@@ -1,6 +1,12 @@
+import { type UUIDVersion as _UUIDVersion } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is an "UUID".
+ * Validates if value is a "UUID".
  * @validator isUUID
  */
-export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function isUUID(version?: isUUID.UUIDVersion, options?: isUUID.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isUUID {
+    type UUIDVersion = _UUIDVersion;
+    interface Options extends ValidationOptions {
+    }
+}

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

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

package/rules/format-rules/is-vat-number.d.ts

@@ -1,6 +1,12 @@
+import { type VATCountryCode as _VATCountryCode } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is an VAT number
+ * Validates if value is a VAT number
  * @validator isVAT
  */
-export declare function isVATNumber(countryCode: string, options?: ValidationOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function isVATNumber(countryCode: isVATNumber.CountryCode, options?: isVATNumber.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isVATNumber {
+    type CountryCode = _VATCountryCode;
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/format-rules/is-vat-number.js

@@ -1,7 +1,7 @@
 import validatorJS from '@browsery/validator';
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is an VAT number
+ * Validates if value is a VAT number
  * @validator isVAT
  */
 export function isVATNumber(countryCode, options) {

package/rules/format-rules/matches.d.ts

@@ -1,9 +1,11 @@
 import { type ValidationOptions } from '../../core/index.js';
-export interface IsRegExpOptions extends ValidationOptions {
-    formatName?: string;
-}
 /**
  * Coerces given value to "UUID" format or returns undefined if nullish
  * @validator uuid
  */
-export declare function matches(format: string | RegExp, options?: IsRegExpOptions): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function matches(format: string | RegExp, options?: matches.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare namespace matches {
+    interface Options extends ValidationOptions {
+        formatName?: string;
+    }
+}

package/rules/index.d.ts

@@ -1,4 +1,5 @@
 export * from './format-rules/is-alpha.js';
+export * from './format-rules/is-alphanumeric.js';
 export * from './format-rules/is-ascii.js';
 export * from './format-rules/is-base64.js';
 export * from './format-rules/is-btc-address.js';
@@ -21,7 +22,9 @@ 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-swift.js';
 export * from './format-rules/is-time.js';
+export * from './format-rules/is-uppercase.js';
 export * from './format-rules/is-url.js';
 export * from './format-rules/is-uuid.js';
 export * from './format-rules/is-vat-number.js';
@@ -29,6 +32,11 @@ export * from './format-rules/matches.js';
 export * from './logical-rules/is-defined.js';
 export * from './logical-rules/is-empty.js';
 export * from './logical-rules/is-equal.js';
+export * from './logical-rules/is-gt.js';
+export * from './logical-rules/is-gte.js';
+export * from './logical-rules/is-lt.js';
+export * from './logical-rules/is-lte.js';
+export * from './logical-rules/length.js';
 export * from './logical-rules/range.js';
 export * from './type-rules/is-any.js';
 export * from './type-rules/is-array.js';
@@ -51,3 +59,4 @@ export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';
 export * from './utility-rules/required.js';
+export * from './utility-rules/string-utils.js';

package/rules/index.js

@@ -1,4 +1,5 @@
 export * from './format-rules/is-alpha.js';
+export * from './format-rules/is-alphanumeric.js';
 export * from './format-rules/is-ascii.js';
 export * from './format-rules/is-base64.js';
 export * from './format-rules/is-btc-address.js';
@@ -21,7 +22,9 @@ 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-swift.js';
 export * from './format-rules/is-time.js';
+export * from './format-rules/is-uppercase.js';
 export * from './format-rules/is-url.js';
 export * from './format-rules/is-uuid.js';
 export * from './format-rules/is-vat-number.js';
@@ -29,6 +32,11 @@ export * from './format-rules/matches.js';
 export * from './logical-rules/is-defined.js';
 export * from './logical-rules/is-empty.js';
 export * from './logical-rules/is-equal.js';
+export * from './logical-rules/is-gt.js';
+export * from './logical-rules/is-gte.js';
+export * from './logical-rules/is-lt.js';
+export * from './logical-rules/is-lte.js';
+export * from './logical-rules/length.js';
 export * from './logical-rules/range.js';
 export * from './type-rules/is-any.js';
 export * from './type-rules/is-array.js';
@@ -51,3 +59,4 @@ export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';
 export * from './utility-rules/required.js';
+export * from './utility-rules/string-utils.js';

package/rules/logical-rules/is-defined.d.ts

@@ -3,4 +3,8 @@ import { type ValidationOptions } from '../../core/index.js';
  * Validates if value is not "undefined" nor "null"
  * @validator isDefined
  */
-export declare function isDefined(options?: ValidationOptions): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare function isDefined(options?: isDefined.Options): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isDefined {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/logical-rules/is-empty.d.ts

@@ -1,11 +1,19 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Checks if value is an empty. Value should be string, array, set, map or object
+ * Checks if the value is empty. Value should be string, array, set, map or object
  * @validator isEmpty
  */
-export declare function isEmpty(options?: ValidationOptions): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare function isEmpty(options?: isEmpty.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isEmpty {
+    interface Options extends ValidationOptions {
+    }
+}
 /**
- * Checks if value is a not empty. Value should be string, array, set, map or object
+ * Checks if the value is not empty. Value should be string, array, set, map or object
  * @validator isNotEmpty
  */
-export declare function isNotEmpty(options?: ValidationOptions): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare function isNotEmpty(options?: isNotEmpty.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isNotEmpty {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/logical-rules/is-empty.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Checks if value is an empty. Value should be string, array, set, map or object
+ * Checks if the value is empty. Value should be string, array, set, map or object
  * @validator isEmpty
  */
 export function isEmpty(options) {
@@ -48,7 +48,7 @@ export function isEmpty(options) {
     }, options);
 }
 /**
- * Checks if value is a not empty. Value should be string, array, set, map or object
+ * Checks if the value is not empty. Value should be string, array, set, map or object
  * @validator isNotEmpty
  */
 export function isNotEmpty(options) {

package/rules/logical-rules/is-equal.d.ts

@@ -3,9 +3,17 @@ import { type ValidationOptions } from '../../core/index.js';
  *
  * @validator isEqual
  */
-export declare function isEqual<T>(compare: T, options?: ValidationOptions): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare function isEqual<T>(compare: T, options?: isEqual.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isEqual {
+    interface Options extends ValidationOptions {
+    }
+}
 /**
  *
  * @validator isNotEqual
  */
-export declare function isNotEqual(compare: any, options?: ValidationOptions): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare function isNotEqual(compare: any, options?: isNotEqual.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isNotEqual {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/logical-rules/is-gt.d.ts

@@ -0,0 +1,12 @@
+import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { range } from './range.js';
+/**
+ * Checks if value is grater than "minValue"
+ * @validator iGt
+ */
+export declare function isGt<T extends range.Input>(minValue: T, options?: isGt.Options): Validator;
+export declare namespace isGt {
+    interface Options extends ValidationOptions {
+        caseInsensitive?: boolean;
+    }
+}

package/rules/logical-rules/is-gt.js

@@ -0,0 +1,27 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Checks if value is grater than "minValue"
+ * @validator iGt
+ */
+export function isGt(minValue, options) {
+    return validator('isGt', (input, context, _this) => {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input > minValue) {
+            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()))) {
+            return input;
+        }
+        context.fail(_this, `Value must be greater than ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
+    }, options);
+}

package/rules/logical-rules/is-gte.d.ts

@@ -0,0 +1,12 @@
+import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { range } from './range.js';
+/**
+ * Checks if value is grater than or equal to minValue
+ * @validator isGte
+ */
+export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T, T>;
+export declare namespace isGte {
+    interface Options extends ValidationOptions {
+        caseInsensitive?: boolean;
+    }
+}

package/rules/logical-rules/is-gte.js

@@ -0,0 +1,27 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Checks if value is grater than or equal to minValue
+ * @validator isGte
+ */
+export function isGte(minValue, options) {
+    return validator('isGte', (input, context, _this) => {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue) {
+            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()))) {
+            return input;
+        }
+        context.fail(_this, `Value must be greater than or equal to ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
+    }, options);
+}

package/rules/logical-rules/is-lt.d.ts

@@ -0,0 +1,12 @@
+import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { range } from './range.js';
+/**
+ * Checks if the value is lover than maxValue
+ * @validator isLt
+ */
+export declare function isLt<T extends range.Input>(maxValue: T, options?: isLt.Options): Validator;
+export declare namespace isLt {
+    interface Options extends ValidationOptions {
+        caseInsensitive?: boolean;
+    }
+}

package/rules/logical-rules/is-lt.js

@@ -0,0 +1,27 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Checks if the value is lover than maxValue
+ * @validator isLt
+ */
+export function isLt(maxValue, options) {
+    return validator('isLt', (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()))) {
+            return input;
+        }
+        context.fail(_this, `Value must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
+    }, options);
+}

package/rules/logical-rules/is-lte.d.ts

@@ -0,0 +1,12 @@
+import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { range } from './range.js';
+/**
+ * Checks if the value is lover than or equal to maxValue
+ * @validator isLte
+ */
+export declare function isLte<T extends range.Input>(maxValue: T, options?: isLte.Options): Validator;
+export declare namespace isLte {
+    interface Options extends ValidationOptions {
+        caseInsensitive?: boolean;
+    }
+}

package/rules/logical-rules/is-lte.js

@@ -0,0 +1,27 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Checks if the value is lover than or equal to maxValue
+ * @validator isLte
+ */
+export function isLte(maxValue, options) {
+    return validator('isLte', (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()))) {
+            return input;
+        }
+        context.fail(_this, `Value must be lover than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
+    }, options);
+}

package/rules/logical-rules/length.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
+ */
+export declare const lengthMin: (minValue: number) => import("../../index.js").Validator<any, any, import("../../index.js").ExecutionOptions>;
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator lengthMax
+ */
+export declare const lengthMax: (maxValue: number) => import("../../index.js").Validator<any, any, import("../../index.js").ExecutionOptions>;

package/rules/logical-rules/length.js

@@ -0,0 +1,29 @@
+import { allOf } from '../utility-rules/all-of.js';
+import { getLength } from '../utility-rules/get-length.js';
+import { pipe } from '../utility-rules/pipe.js';
+import { isGte } from './is-gte.js';
+import { isLte } from './is-lte.js';
+/**
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
+ */
+export const lengthMin = (minValue) => allOf([
+    pipe([
+        getLength(),
+        isGte(minValue, {
+            onFail: () => `Value length 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/rules/logical-rules/range.d.ts

@@ -1,46 +1,10 @@
-import { type ValidationOptions, type Validator } from '../../core/index.js';
-type RangeInput = number | bigint | Date | string;
+import { type ValidationOptions } from '../../core/index.js';
 /**
  * Checks if value is between minValue and maxValue
  * @validator range
  */
-export declare function range<T extends RangeInput>(minValue: T, maxValue: T, options?: ValidationOptions): Validator<T, T, import("../../core/types.js").ExecutionOptions>;
-/**
- * Checks if value is grater than "minValue"
- * @validator iGt
- */
-export declare function isGt<T extends RangeInput>(minValue: T, options?: ValidationOptions & {
-    caseInsensitive?: boolean;
-}): Validator;
-/**
- * Checks if value is grater than or equal to minValue
- * @validator isGte
- */
-export declare function isGte<T extends RangeInput>(minValue: T, options?: ValidationOptions & {
-    caseInsensitive?: boolean;
-}): Validator<T, T>;
-/**
- * Checks if number value is lover than maxValue
- * @validator isLt
- */
-export declare function isLt<T extends RangeInput>(maxValue: T, options?: ValidationOptions & {
-    caseInsensitive?: boolean;
-}): Validator;
-/**
- * Checks if value is lover than or equal to maxValue
- * @validator isLte
- */
-export declare function isLte<T extends RangeInput>(maxValue: T, options?: ValidationOptions & {
-    caseInsensitive?: boolean;
-}): Validator;
-/**
- * Checks the length is at least "minValue"
- * @validator lengthMin
- */
-export declare const lengthMin: (minValue: number) => Validator<any, any, import("../../core/types.js").ExecutionOptions>;
-/**
- * Checks if the length is at most "maxValue"
- * @validator lengthMax
- */
-export declare const lengthMax: (maxValue: number) => Validator<any, any, import("../../core/types.js").ExecutionOptions>;
-export {};
+export declare function range<T extends range.Input>(minValue: T, maxValue: T, options?: range.Options): import("../../core/validator.js").Validator<T, T, import("../../core/types.js").ExecutionOptions>;
+export declare namespace range {
+    type Input = number | bigint | Date | string;
+    type Options = ValidationOptions;
+}