reslib 1.0.0

package/build/validator/rules/numeric.d.ts

@@ -0,0 +1,1135 @@
+/**
+ * ### IsNumberLTE Decorator
+ *
+ * Validates that a numeric field has a value less than or equal to a specified maximum.
+ * This decorator ensures that input values do not exceed a defined upper limit.
+ *
+ * ### Purpose
+ * Useful for enforcing maximum values in numeric inputs such as:
+ * - Age limits (must be ≤ 120 years)
+ * - Quantity limits (must be ≤ maximum stock)
+ * - Score ranges (must be ≤ 100 points)
+ * - Price ceilings (must be ≤ maximum allowed price)
+ *
+ * ### Parameters
+ * Takes a single numeric parameter representing the maximum allowed value (inclusive).
+ *
+ * ### Validation Logic
+ * 1. **Type Conversion**: Converts input values to numbers using `toNumber()`
+ * 2. **NaN Handling**: Rejects if either value or comparison parameter is NaN
+ * 3. **Comparison**: Checks if `value ≤ comparisonValue`
+ * 4. **Result**: Passes if value is ≤ limit, fails otherwise
+ *
+ * ### Return Behavior
+ * - **Success**: Resolves with `true` if `value ≤ maxValue`
+ * - **Failure**: Rejects with localized error message if `value > maxValue`
+ * - **Invalid Input**: Rejects if values cannot be converted to numbers
+ * - **Missing Parameter**: Resolves with error if no comparison value provided
+ *
+ * ### Examples
+ *
+ * #### Basic Usage - Age Validation
+ * ```typescript
+ * class Person {
+ *   @IsNumberLTE(120)
+ *   age: number; // Must be ≤ 120 years
+ * }
+ *
+ * // Valid: 25, 120, 0
+ * // Invalid: 121, 150
+ * ```
+ *
+ * #### Quantity Limits
+ * ```typescript
+ * class Order {
+ *   @IsNumberLTE(1000)
+ *   quantity: number; // Maximum 1000 units per order
+ *
+ *   @IsNumberLTE(100)
+ *   discountPercent: number; // Max 100% discount
+ * }
+ * ```
+ *
+ * #### Score Validation
+ * ```typescript
+ * class Exam {
+ *   @IsNumberLTE(100)
+ *   score: number; // Test scores out of 100
+ *
+ *   @IsNumberLTE(50)
+ *   bonusPoints: number; // Max 50 bonus points
+ * }
+ * ```
+ *
+ * #### Price Ceilings
+ * ```typescript
+ * class Product {
+ *   @IsNumberLTE(999.99)
+ *   price: number; // Maximum retail price
+ *
+ *   @IsNumberLTE(100)
+ *   markupPercent: number; // Max 100% markup
+ * }
+ * ```
+ *
+ * ### Error Messages
+ * Uses i18n translation key: `validator.numberLTE`
+ * Default format: "The {field} must be less than or equal to {comparisonValue}"
+ *
+ * ### Type Safety
+ * - Strongly typed with TypeScript generics
+ * - Parameter validation at compile time
+ * - Runtime type checking and conversion
+ *
+ * ### Performance Notes
+ * - Efficient numeric conversion and comparison
+ * - Early termination on invalid inputs
+ * - Minimal memory allocation
+ *
+ * ### Related Decorators
+ * - {@link IsNumberGTE}: Opposite validation (minimum values)
+ * - {@link IsNumberLT}: Strict less than validation
+ * - {@link IsNumberGT}: Strict greater than validation
+ * - {@link IsNumberBetween}: Range validation
+ *
+ * ### Implementation Details
+ * Uses the `compareNumer` helper function for consistent numeric validation
+ * across all comparison decorators. Handles edge cases like NaN values and
+ * type conversion automatically.
+ *
+ * @decorator
+ * @public
+ */
+export declare const IsNumberLTE: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * @decorator IsNumberLT
+ *
+ * Validator rule that checks if a given number is less than a specified value.
+ * This rule utilizes the `compareNumer` function to perform the comparison and return the result.
+ *
+ * ### Parameters:
+ * - **options**: `ValidatorValidateOptions` - An object containing:
+ *   - `value`: The number to validate.
+ *   - `ruleParams`: An array where the first element is the value to compare against.
+ *
+ * ### Return Value:
+ * - `ValidatorResult`: Resolves to `true` if the value is less than the specified comparison value,
+ *   otherwise rejects with an error message indicating the validation failure.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * class MyClass {
+ *     @IsNumberLT(10)
+ *     myNumber: number;
+ * }
+ * ```
+ *
+ * ### Notes:
+ * - This rule is useful for scenarios where you need to ensure that a numeric input is strictly less than a specified limit.
+ * - The error message can be customized by modifying the second parameter of the `compareNumer` function.
+ */
+export declare const IsNumberLT: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * @decorator IsNumberGTE
+ *
+ * Validator rule that checks if a given number is greater than or equal to a specified value.
+ * This rule utilizes the `compareNumer` function to perform the comparison and return the result.
+ *
+ * ### Parameters:
+ * - **options**: `ValidatorValidateOptions` - An object containing:
+ *   - `value`: The number to validate.
+ *   - `ruleParams`: An array where the first element is the value to compare against.
+ *
+ * ### Return Value:
+ * - `ValidatorResult`: Resolves to `true` if the value is greater than or equal to the specified comparison value,
+ *   otherwise rejects with an error message indicating the validation failure.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * class MyClass {
+ *     @IsNumberGTE(5)
+ *     myNumber: number;
+ * }
+ * ```
+ *
+ * ### Notes:
+ * - This rule is useful for scenarios where you need to ensure that a numeric input meets or exceeds a specified limit.
+ * - The error message can be customized by modifying the second parameter of the `compareNumer` function.
+ */
+export declare const IsNumberGTE: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * @decorator IsNumberGT
+ *
+ * Validator rule that checks if a given number is greater than a specified value.
+ * This rule utilizes the `compareNumer` function to perform the comparison and return the result.
+ *
+ * ### Parameters:
+ * - **options**: `ValidatorValidateOptions` - An object containing:
+ *   - `value`: The number to validate.
+ *   - `ruleParams`: An array where the first element is the value to compare against.
+ *
+ * ### Return Value:
+ * - `ValidatorResult`: Resolves to `true` if the value is greater than the specified comparison value,
+ *   otherwise rejects with an error message indicating the validation failure.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * class MyClass {
+ *     @IsNumberGT([10])
+ *     myNumber: number;
+ * }
+ * ```
+ *
+ * ### Notes:
+ * - This rule is useful for scenarios where you need to ensure that a numeric input exceeds a specified limit.
+ * - The error message can be customized by modifying the second parameter of the `compareNumer` function.
+ */
+export declare const IsNumberGT: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * @decorator  IsNumberEQ
+ *
+ * Validator rule that checks if a given number is equal to a specified value.
+ * This rule utilizes the `compareNumer` function to perform the comparison and return the result.
+ *
+ * ### Parameters:
+ * - **options**: `ValidatorValidateOptions` - An object containing:
+ *   - `value`: The number to validate.
+ *   - `ruleParams`: An array where the first element is the value to compare against.
+ *
+ * ### Return Value:
+ * - `ValidatorResult`: Resolves to `true` if the value is equal to the specified comparison value,
+ *   otherwise rejects with an error message indicating the validation failure.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * class MyClass {
+ *     @ IsNumberEQ([10])
+ *     myNumber: number;
+ * }
+ * ```
+ *
+ * ### Notes:
+ * - This rule is useful for scenarios where you need to ensure that a numeric input matches a specified value exactly.
+ * - The error message can be customized by modifying the second parameter of the `compareNumer` function.
+ */
+export declare const IsNumberEQ: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * @decorator IsNumberNE
+ *
+ * Validator rule that checks if a given number is not equal to a specified value.
+ * This rule utilizes the `compareNumer` function to perform the comparison and return the result.
+ *
+ * ### Example Usage:
+ * ```typescript
+ * class MyClass {
+ *     @IsNumberNE([10])
+ *     myNumber: number;
+ * }
+ * ```
+ */
+export declare const IsNumberNE: (ruleParameters_0: number) => PropertyDecorator;
+/**
+ * ## Pre-Built Validation Decorators
+ *
+ * Collection of commonly used validation decorators that provide immediate
+ * validation capabilities for standard data types and formats. These decorators
+ * are built on top of registered validation rules and provide a convenient
+ * way to apply common validations.
+ */
+/**
+ * ### IsNumber Decorator
+ *
+ * Validates that a property value is a valid number. This decorator checks
+ * for numeric values and rejects non-numeric inputs.
+ *
+ * @example
+ * ```typescript
+ * class Product {
+ *   @IsNumber()
+ *   price: number;
+ *
+ *   @IsNumber()
+ *   quantity: number;
+ *
+ *   @IsRequired()
+ *   @IsNumber()
+ *   weight: number;
+ * }
+ *
+ * // Valid data
+ * const product = { price: 19.99, quantity: 5, weight: 2.5 };
+ *
+ * // Invalid data
+ * const invalid = { price: "not-a-number", quantity: 5, weight: 2.5 };
+ * // Will fail validation with error: "Price must be a number"
+ * ```
+ *
+ * @decorator
+ *
+ * @see {@link IsRequired} - Often used together
+ * @public
+ */
+export declare const IsNumber: () => PropertyDecorator;
+/**
+ * ### IsNumberBetween Rule (Numeric)
+ *
+ * Validates that the field under validation has a numeric value between the
+ * given minimum and maximum values (inclusive).
+ *
+ * #### Parameters
+ * - `min` - Minimum value (inclusive)
+ * - `max` - Maximum value (inclusive)
+ *
+ * @example
+ * ```typescript
+ * // Class validation
+ * class Product {
+ *   @IsNumberBetween([1, 999])
+ *   quantity: number;
+ *
+ *   @IsNumberBetween([0.01, 9999.99])
+ *   price: number;
+ *
+ *   @IsNumberBetween([0, 100])
+ *   discountPercentage: number;
+ * }
+ * ```
+ *
+ * @param options - Validation options with rule parameters
+ * @param options.ruleParams - Array containing [min, max] values
+ * @returns true if valid, rejecting with error message if invalid
+ *
+ *
+ * @public
+ */
+export declare const IsNumberBetween: (min: number, max: number) => PropertyDecorator;
+/**
+ * ### HasDecimalPlaces Rule
+ *
+ * Validates that the field under validation is numeric and contains the
+ * specified number of decimal places.
+ *
+ * #### Parameters
+ * - `places` - Exact number of decimal places required
+ * - `min,max` (optional) - Range of decimal places allowed
+ *
+ * @example
+ * ```typescript
+ * // Class validation
+ * class Financial {
+ *   @HasDecimalPlaces([2])
+ *   price: number; // Must have exactly 2 decimal places
+ *
+ *   @HasDecimalPlaces([0, 4])
+ *   exchangeRate: number; // 0-4 decimal places allowed
+ *
+ *   @HasDecimalPlaces([3])
+ *   weight: number; // Exactly 3 decimal places for precision
+ * }
+ * ```
+ *
+ * @param options - Validation options with rule parameters
+ * @param options.ruleParams - Array with decimal places specification
+ * @returns true if valid, rejecting with error message if invalid
+ *
+ *
+ * @public
+ */
+export declare const HasDecimalPlaces: (minDecimalPlaces: number, maxDecimalPlaces?: number | undefined) => PropertyDecorator;
+/**
+ * ### IsInteger Rule
+ *
+ * Validates that the field under validation is an Integer. This rule does not
+ * verify that the input is of the "Integer" variable type, only that the input
+ * is a string or numeric value that contains an Integer.
+ *
+ * @example
+ * ```typescript
+ * class Inventory {
+ *   @Integer
+ *   quantity: number;
+ *
+ *   @Integer
+ *   @Min([0])
+ *   stockLevel: number;
+ *
+ *   @Integer
+ *   @NumberBetween([-1000, 1000])
+ *   adjustment: number;
+ * }
+ * ```
+ *
+ * @returns true if valid, rejecting with error message if invalid
+ *
+ *
+ * @public
+ */
+export declare const IsInteger: () => PropertyDecorator;
+/**
+ * ### IsEvenNumber Decorator
+ *
+ * Validates that the field under validation is an integer and even (divisible by 2).
+ * Non-numeric inputs or non-integer numbers fail with appropriate messages.
+ *
+ * @example
+ * ```typescript
+ * class Model {
+ *   @IsEvenNumber()
+ *   evenId: number;
+ * }
+ * ```
+ * * @example
+ * ```typescript
+ * // Class validation with decorator
+ * class Invoice {
+ *   @IsEvenNumber()
+ *   batchNumber: number; // Must be an even integer (e.g., 2, 4, 6)
+ * }
+ *
+ * // Direct rule usage
+ * await Validator.validate({
+ *   value: 42,
+ *   rules: ['EvenNumber']
+ * }); // ✓ Valid
+ *
+ * await Validator.validate({
+ *   value: 7,
+ *   rules: ['EvenNumber']
+ * }); // ✗ Invalid (odd)
+ * ```
+ *
+ * @public
+ */
+export declare const IsEvenNumber: () => PropertyDecorator;
+/**
+ * ### IsOddNumber Decorator
+ *
+ * Validates that the field under validation is an integer and odd (not divisible by 2).
+ * Non-numeric inputs or non-integer numbers fail with appropriate messages.
+ *
+ * @example
+ * ```typescript
+ * class Model {
+ *   @IsOddNumber()
+ *   oddId: number;
+ * }
+ * ```
+ * * @example
+ * ```typescript
+ * // Class validation with decorator
+ * class Invoice {
+ *   @IsOddNumber()
+ *   ticketNumber: number; // Must be an odd integer (e.g., 1, 3, 5)
+ * }
+ *
+ * // Direct rule usage
+ * await Validator.validate({
+ *   value: 9,
+ *   rules: ['OddNumber']
+ * }); // ✓ Valid
+ *
+ * await Validator.validate({
+ *   value: 10,
+ *   rules: ['OddNumber']
+ * }); // ✗ Invalid (even)
+ * ```
+ *
+ * @public
+ */
+export declare const IsOddNumber: () => PropertyDecorator;
+/**
+ * ### Multiple Of Rule
+ *
+ * Validates that the field under validation is a multiple of the specified value.
+ * This is useful for ensuring values conform to specific increments.
+ *
+ * #### Parameters
+ * - `multiple` - The value that the field must be a multiple of
+ *
+ * @example
+ * ```typescript
+ * // Multiple validation
+ * class Pricing {
+ *   @IsMultipleOf(0.01)
+ *   price: number; // Must be in cent increments
+ *
+ *   @IsMultipleOf(5)
+ *   discountPercent: number; // 5% increments
+ *
+ *   @IsMultipleOf(15)
+ *   appointmentDuration: number; // 15-minute slots
+ * }
+ * ```
+ *
+ * @param options - Validation options with rule parameters
+ * @param options.ruleParams - Array containing the multiple value
+ * @returns true if valid, rejecting with error message if invalid
+ *
+ *
+ * @public
+ */
+export declare const IsMultipleOf: (ruleParameters_0: number) => PropertyDecorator;
+declare module '../types' {
+    interface ValidatorRuleParamTypes {
+        /**
+         * ### Number Rule
+         *
+         * Validates that the field under validation is a valid number. This rule checks
+         * for numeric values and rejects non-numeric inputs. It accepts both integers
+         * and floating-point numbers.
+         *
+         * @example
+         * ```typescript
+         * // Valid numeric values
+         * await Validator.validate({
+         *   value: 42,
+         *   rules: ['Number']
+         * }); // ✓ Valid
+         *
+         * await Validator.validate({
+         *   value: 3.14,
+         *   rules: ['Number']
+         * }); // ✓ Valid (decimal)
+         *
+         * await Validator.validate({
+         *   value: -123,
+         *   rules: ['Number']
+         * }); // ✓ Valid (negative)
+         *
+         * await Validator.validate({
+         *   value: '456',
+         *   rules: ['Number']
+         * }); // ✓ Valid (numeric string)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 'abc',
+         *   rules: ['Number']
+         * }); // ✗ Invalid (non-numeric string)
+         *
+         * await Validator.validate({
+         *   value: null,
+         *   rules: ['Number']
+         * }); // ✗ Invalid (null)
+         *
+         * await Validator.validate({
+         *   value: {},
+         *   rules: ['Number']
+         * }); // ✗ Invalid (object)
+         *
+         * // Class validation
+         * class Product {
+         *   @IsNumber()
+         *   price: number;
+         *
+         *   @IsNumber()
+         *   quantity: number;
+         * }
+         * ```
+         *
+         * @returns true if valid number, rejecting with error message if invalid
+         *
+         * @public
+         */
+        Number: ValidatorRuleParams<[]>;
+        /**
+         * ### NumberLTE Rule
+         *
+         * Validates that the field under validation has a numeric value less than or equal to
+         * a specified maximum value. This rule ensures that input values do not exceed
+         * a defined upper limit.
+         *
+         * #### Parameters
+         * - `max` - Maximum allowed value (inclusive)
+         *
+         * @example
+         * ```typescript
+         * // Age limit validation
+         * await Validator.validate({
+         *   value: 25,
+         *   rules: [{NumberLTE: [120]}]
+         * }); // ✓ Valid (age ≤ 120)
+         *
+         * await Validator.validate({
+         *   value: 120,
+         *   rules: [{NumberLTE: [120]}]
+         * }); // ✓ Valid (exactly 120)
+         *
+         * // Quantity limit validation
+         * await Validator.validate({
+         *   value: 500,
+         *   rules: [{NumberLTE: [1000]}]
+         * }); // ✓ Valid (quantity ≤ 1000)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 150,
+         *   rules: [{NumberLTE: [120]}]
+         * }); // ✗ Invalid (age > 120)
+         *
+         * // Class validation
+         * class Person {
+         *   @IsNumberLTE(120)
+         *   age: number; // Must be ≤ 120 years
+         * }
+         *
+         * class Order {
+         *   @IsNumberLTE(1000)
+         *   quantity: number; // Maximum 1000 units
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the maximum value
+         * @returns true if value ≤ max, rejecting with error message if value > max
+         *
+         *
+         * @public
+         */
+        NumberLTE: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberLT Rule
+         *
+         * Validates that the field under validation has a numeric value strictly less than
+         * a specified maximum value. This rule ensures that input values stay below
+         * a defined upper limit (exclusive).
+         *
+         * #### Parameters
+         * - `max` - Maximum allowed value (exclusive)
+         *
+         * @example
+         * ```typescript
+         * // Age limit validation (must be under 18 for minors)
+         * await Validator.validate({
+         *   value: 17,
+         *   rules: [{NumberLT: [18]}]
+         * }); // ✓ Valid (age < 18)
+         *
+         * await Validator.validate({
+         *   value: 17.9,
+         *   rules: [{NumberLT: [18]}]
+         * }); // ✓ Valid (still < 18)
+         *
+         * // Discount limit validation
+         * await Validator.validate({
+         *   value: 49.99,
+         *   rules: [{NumberLT: [50]}]
+         * }); // ✓ Valid (discount < 50%)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 18,
+         *   rules: [{NumberLT: [18]}]
+         * }); // ✗ Invalid (18 is not < 18)
+         *
+         * await Validator.validate({
+         *   value: 25,
+         *   rules: [{NumberLT: [18]}]
+         * }); // ✗ Invalid (25 > 18)
+         *
+         * // Class validation
+         * class Minor {
+         *   @IsNumberLT(18)
+         *   age: number; // Must be < 18 years
+         * }
+         *
+         * class Discount {
+         *   @IsNumberLT(50)
+         *   percentage: number; // Must be < 50%
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the exclusive maximum value
+         * @returns true if value < max, rejecting with error message if value ≥ max
+         *
+         *
+         * @public
+         */
+        NumberLT: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberGTE Rule
+         *
+         * Validates that the field under validation has a numeric value greater than or equal to
+         * a specified minimum value. This rule ensures that input values meet or exceed
+         * a defined lower limit (inclusive).
+         *
+         * #### Parameters
+         * - `min` - Minimum allowed value (inclusive)
+         *
+         * @example
+         * ```typescript
+         * // Age requirement validation (must be 18 or older)
+         * await Validator.validate({
+         *   value: 18,
+         *   rules: [{NumberGTE: [18]}]
+         * }); // ✓ Valid (age ≥ 18)
+         *
+         * await Validator.validate({
+         *   value: 25,
+         *   rules: [{NumberGTE: [18]}]
+         * }); // ✓ Valid (age > 18)
+         *
+         * // Minimum balance validation
+         * await Validator.validate({
+         *   value: 100.00,
+         *   rules: [{NumberGTE: [50.00]}]
+         * }); // ✓ Valid (balance ≥ $50)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 17,
+         *   rules: [{NumberGTE: [18]}]
+         * }); // ✗ Invalid (17 < 18)
+         *
+         * await Validator.validate({
+         *   value: 17.9,
+         *   rules: [{NumberGTE: [18]}]
+         * }); // ✗ Invalid (17.9 < 18)
+         *
+         * // Class validation
+         * class Adult {
+         *   @IsNumberGTE(18)
+         *   age: number; // Must be ≥ 18 years
+         * }
+         *
+         * class Account {
+         *   @IsNumberGTE(0)
+         *   balance: number; // Must be ≥ $0
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the inclusive minimum value
+         * @returns true if value ≥ min, rejecting with error message if value < min
+         *
+         *
+         * @public
+         */
+        NumberGTE: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberGT Rule
+         *
+         * Validates that the field under validation has a numeric value strictly greater than
+         * a specified minimum value. This rule ensures that input values exceed
+         * a defined lower limit (exclusive).
+         *
+         * #### Parameters
+         * - `min` - Minimum allowed value (exclusive)
+         *
+         * @example
+         * ```typescript
+         * // Age requirement validation (must be over 18)
+         * await Validator.validate({
+         *   value: 19,
+         *   rules: [{NumberGT: [18]}]
+         * }); // ✓ Valid (age > 18)
+         *
+         * await Validator.validate({
+         *   value: 18.1,
+         *   rules: [{NumberGT: [18]}]
+         * }); // ✓ Valid (age > 18)
+         *
+         * // Minimum purchase validation
+         * await Validator.validate({
+         *   value: 100.01,
+         *   rules: [{NumberGT: [100]}]
+         * }); // ✓ Valid (amount > $100)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 18,
+         *   rules: [{NumberGT: [18]}]
+         * }); // ✗ Invalid (18 is not > 18)
+         *
+         * await Validator.validate({
+         *   value: 15,
+         *   rules: [{NumberGT: [18]}]
+         * }); // ✗ Invalid (15 < 18)
+         *
+         * // Class validation
+         * class Senior {
+         *   @IsNumberGT(65)
+         *   age: number; // Must be > 65 years
+         * }
+         *
+         * class Premium {
+         *   @IsNumberGT(1000)
+         *   purchaseAmount: number; // Must be > $1000
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the exclusive minimum value
+         * @returns true if value > min, rejecting with error message if value ≤ min
+         *
+         *
+         * @public
+         */
+        NumberGT: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberEQ Rule
+         *
+         * Validates that the field under validation has a numeric value exactly equal to
+         * a specified target value. This rule ensures that input values match
+         * a precise numeric requirement.
+         *
+         * #### Parameters
+         * - `target` - Exact value that the field must equal
+         *
+         * @example
+         * ```typescript
+         * // PIN code validation (must be exactly 1234)
+         * await Validator.validate({
+         *   value: 1234,
+         *   rules: [{NumberEQ: [1234]}]
+         * }); // ✓ Valid (exact match)
+         *
+         * // Magic number validation
+         * await Validator.validate({
+         *   value: 42,
+         *   rules: [{NumberEQ: [42]}]
+         * }); // ✓ Valid (exact match)
+         *
+         * // Version number validation
+         * await Validator.validate({
+         *   value: 1.0,
+         *   rules: [{NumberEQ: [1.0]}]
+         * }); // ✓ Valid (exact match)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 1235,
+         *   rules: [{NumberEQ: [1234]}]
+         * }); // ✗ Invalid (not equal)
+         *
+         * await Validator.validate({
+         *   value: 41.9,
+         *   rules: [{NumberEQ: [42]}]
+         * }); // ✗ Invalid (not equal)
+         *
+         * // Class validation
+         * class AccessCode {
+         *   @IsNumberEQ(1234)
+         *   pinCode: number; // Must be exactly 1234
+         * }
+         *
+         * class Version {
+         *   @IsNumberEQ(1.0)
+         *   versionNumber: number; // Must be exactly 1.0
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the exact target value
+         * @returns true if value === target, rejecting with error message if value !== target
+         *
+         *
+         * @public
+         */
+        NumberEQ: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberNE Rule
+         *
+         * Validates that the field under validation has a numeric value different from
+         * a specified forbidden value. This rule ensures that input values do not match
+         * a particular number that should be avoided.
+         *
+         * #### Parameters
+         * - `forbidden` - Value that the field must not equal
+         *
+         * @example
+         * ```typescript
+         * // Reserved number validation (cannot be 0)
+         * await Validator.validate({
+         *   value: 5,
+         *   rules: [{NumberNE: [0]}]
+         * }); // ✓ Valid (not 0)
+         *
+         * await Validator.validate({
+         *   value: -1,
+         *   rules: [{NumberNE: [0]}]
+         * }); // ✓ Valid (not 0)
+         *
+         * // Forbidden ID validation
+         * await Validator.validate({
+         *   value: 123,
+         *   rules: [{NumberNE: [999]}]
+         * }); // ✓ Valid (not 999)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 0,
+         *   rules: [{NumberNE: [0]}]
+         * }); // ✗ Invalid (equals forbidden value)
+         *
+         * await Validator.validate({
+         *   value: 999,
+         *   rules: [{NumberNE: [999]}]
+         * }); // ✗ Invalid (equals forbidden value)
+         *
+         * // Class validation
+         * class User {
+         *   @IsNumberNE(0)
+         *   userId: number; // Cannot be 0 (reserved)
+         * }
+         *
+         * class Product {
+         *   @IsNumberNE(999)
+         *   sku: number; // Cannot be 999 (test value)
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the forbidden value
+         * @returns true if value !== forbidden, rejecting with error message if value === forbidden
+         *
+         *
+         * @public
+         */
+        NumberNE: ValidatorRuleParams<[number]>;
+        /**
+         * ### NumberBetween Rule (Numeric)
+         *
+         * Validates that the field under validation has a numeric value between the
+         * given minimum and maximum values (inclusive).
+         *
+         * #### Parameters
+         * - `min` - Minimum value (inclusive)
+         * - `max` - Maximum value (inclusive)
+         *
+         * @example
+         * ```typescript
+         * // Age validation
+         * await Validator.validate({
+         *   value: 25,
+         *   rules: [{NumberBetween:[18,65]}]
+         * }); // ✓ Valid
+         *
+         * // Price range validation
+         * await Validator.validate({
+         *   value: 99.99,
+         *   rules: [{NumberBetween:[10.00,999.99]}]
+         * }); // ✓ Valid
+         *
+         * // Percentage validation
+         * await Validator.validate({
+         *   value: 85,
+         *   rules: [{NumberBetween:[0,100]}]
+         * }); // ✓ Valid
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 17,
+         *   rules: [{NumberBetween:[18,65]}]
+         * }); // ✗ Invalid (below minimum)
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing [min, max] values
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         *
+         * @public
+         */
+        NumberBetween: ValidatorRuleParams<[min: number, max: number]>;
+        /**
+         * ### DecimalPlaces Rule
+         *
+         * Validates that the field under validation is numeric and contains the
+         * specified number of decimal places.
+         *
+         * #### Parameters
+         * - `places` - Exact number of decimal places required
+         * - `min,max` (optional) - Range of decimal places allowed
+         *
+         * @example
+         * ```typescript
+         * // Exact decimal places
+         * await Validator.validate({
+         *   value: 99.99,
+         *   rules: [{DecimalPlaces: [2]}]
+         * }); // ✓ Valid (exactly 2 decimal places)
+         *
+         * await Validator.validate({
+         *   value: 123.456,
+         *   rules: [{DecimalPlaces: [3]}]
+         * }); // ✓ Valid (exactly 3 decimal places)
+         *
+         * // Range of decimal places
+         * await Validator.validate({
+         *   value: 99.9,
+         *   rules: [{DecimalPlaces: [1, 3]}]
+         * }); // ✓ Valid (1-3 decimal places)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 99.999,
+         *   rules: [{DecimalPlaces: [2]}]
+         * }); // ✗ Invalid (3 places, expected 2)
+         *
+         * await Validator.validate({
+         *   value: 99,
+         *   rules: [{DecimalPlaces: [2]}]
+         * }); // ✗ Invalid (0 places, expected 2)
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array with decimal places specification
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         *
+         * @public
+         */
+        DecimalPlaces: ValidatorRuleParams<[
+            minDecimalPlaces: number,
+            maxDecimalPlaces?: number
+        ]>;
+        /**
+         * ### Integer Rule
+         *
+         * Validates that the field under validation is an Integer. This rule does not
+         * verify that the input is of the "Integer" variable type, only that the input
+         * is a string or numeric value that contains an Integer.
+         *
+         * @example
+         * ```typescript
+         * // Valid integers
+         * await Validator.validate({
+         *   value: 42,
+         *   rules: ['Integer']
+         * }); // ✓ Valid
+         *
+         * await Validator.validate({
+         *   value: '123',
+         *   rules: ['Integer']
+         * }); // ✓ Valid (numeric string)
+         *
+         * await Validator.validate({
+         *   value: -456,
+         *   rules: ['Integer']
+         * }); // ✓ Valid (negative Integer)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 12.34,
+         *   rules: ['Integer']
+         * }); // ✗ Invalid (has decimal places)
+         *
+         * await Validator.validate({
+         *   value: 'abc',
+         *   rules: ['Integer']
+         * }); // ✗ Invalid (not numeric)
+         * ```
+         *
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         *
+         * @public
+         */
+        Integer: ValidatorRuleParams<[]>;
+        /**
+         * ### Even Number Rule
+         *
+         * Validates that the field under validation is an integer and even (divisible by 2).
+         * Non-numeric inputs or non-integer numbers will be rejected with precise messages.
+         *
+         * @example
+         * ```typescript
+         * // Valid examples
+         * await Validator.validate({ value: 2, rules: ['EvenNumber'] }); // ✓
+         * await Validator.validate({ value: '8', rules: ['EvenNumber'] }); // ✓ numeric string
+         * await Validator.validate({ value: 0, rules: ['EvenNumber'] }); // ✓ zero is even
+         *
+         * // Invalid examples
+         * await Validator.validate({ value: 3, rules: ['EvenNumber'] }); // ✗ odd
+         * await Validator.validate({ value: 2.5, rules: ['EvenNumber'] }); // ✗ not integer
+         * await Validator.validate({ value: 'abc', rules: ['EvenNumber'] }); // ✗ not numeric
+         * ```
+         *
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         * @public
+         */
+        EvenNumber: ValidatorRuleParams<[]>;
+        /**
+         * ### Multiple Of Rule
+         *
+         * Validates that the field under validation is a multiple of the specified value.
+         * This is useful for ensuring values conform to specific increments.
+         *
+         * #### Parameters
+         * - `multiple` - The value that the field must be a multiple of
+         *
+         * @example
+         * ```typescript
+         * // Multiple validation
+         * await Validator.validate({
+         *   value: 15,
+         *   rules: [{MultipleOf: [5]}]
+         * }); // ✓ Valid (15 is multiple of 5)
+         *
+         * await Validator.validate({
+         *   value: 0.25,
+         *   rules: [{MultipleOf: [0.05]}]
+         * }); // ✓ Valid (price increment validation)
+         *
+         * // Time interval validation
+         * await Validator.validate({
+         *   value: 30,
+         *   rules: [{MultipleOf: [15]}]
+         * }); // ✓ Valid (15-minute intervals)
+         *
+         * // Invalid examples
+         * await Validator.validate({
+         *   value: 17,
+         *   rules: [{MultipleOf: [5]}]
+         * }); // ✗ Invalid (not a multiple of 5)
+         *
+         * // Class validation
+         * class Pricing {
+         *   @IsMultipleOf([0.01])
+         *   price: number; // Must be in cent increments
+         *
+         *   @IsMultipleOf([5])
+         *   discountPercent: number; // 5% increments
+         *
+         *   @IsMultipleOf([15])
+         *   appointmentDuration: number; // 15-minute slots
+         * }
+         * ```
+         *
+         * @param options - Validation options with rule parameters
+         * @param options.ruleParams - Array containing the multiple value
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         *
+         * @public
+         */
+        MultipleOf: ValidatorRuleParams<[number]>;
+        /**
+         * ### Odd Number Rule
+         *
+         * Validates that the field under validation is an integer and odd (not divisible by 2).
+         * Non-numeric inputs or non-integer numbers will be rejected with precise messages.
+         *
+         * @example
+         * ```typescript
+         * // Valid examples
+         * await Validator.validate({ value: 1, rules: ['OddNumber'] }); // ✓
+         * await Validator.validate({ value: '7', rules: ['OddNumber'] }); // ✓ numeric string
+         * await Validator.validate({ value: -5, rules: ['OddNumber'] }); // ✓ negative odd
+         *
+         * // Invalid examples
+         * await Validator.validate({ value: 4, rules: ['OddNumber'] }); // ✗ even
+         * await Validator.validate({ value: 3.14, rules: ['OddNumber'] }); // ✗ not integer
+         * await Validator.validate({ value: 'abc', rules: ['OddNumber'] }); // ✗ not numeric
+         * ```
+         *
+         * @returns true if valid, rejecting with error message if invalid
+         *
+         * @public
+         */
+        OddNumber: ValidatorRuleParams<[]>;
+    }
+}