reslib 1.0.3 → 2.0.0

package/build/validator/validator.d.ts

@@ -1,79 +1,7 @@
 import { ClassConstructor, MakeOptional } from '../types';
 import { I18n } from '../i18n';
-import { ValidatorAsyncResult, ValidatorDefaultMultiRule, ValidatorMultiRuleFunction, ValidatorMultiRuleNames, ValidatorNestedRuleFunctionOptions, ValidatorResult, ValidatorRule, ValidatorRuleFunction, ValidatorRuleFunctionsMap, ValidatorRuleName, ValidatorRuleObject, ValidatorRuleParams, ValidatorRules, ValidatorSanitizedRuleObject, ValidatorSanitizedRules, ValidatorValidateFailure, ValidatorValidateMultiRuleOptions, ValidatorValidateOptions, ValidatorValidateResult, ValidatorValidateSuccess, ValidatorValidateTargetOptions, ValidatorValidateTargetResult } from './types';
-/**
- * # Validator Class
- *
- * A comprehensive validation system that provides flexible and powerful validation capabilities
- * for TypeScript/JavaScript applications. This class supports both synchronous and asynchronous
- * validation, decorator-based validation for classes, and a rich ecosystem of validation rules.
- *
- * ## Key Features
- * - **Type-Safe Validation**: Full TypeScript support with generic types
- * - **Decorator Support**: Class property validation using decorators
- * - **Async Validation**: Support for asynchronous validation rules
- * - **Internationalization**: Built-in i18n support for error messages
- * - **Extensible**: Easy to register custom validation rules
- * - **Rule Composition**: Combine multiple validation rules
- *
- * ## Basic Usage
- * ```typescript
- * // Register a custom validation rule
- * Validator.registerRule('CustomRule', ({ value }) => {
- *   return value > 10 || 'Value must be greater than 10';
- * });
- *
- * // Validate a single value
- * const result = await Validator.validate({
- *   value: 15,
- *   rules: ['Required', 'CustomRule']
- * });
- *
- * // Use with decorators
- * class User {
- *   @IsRequired()
- *   @IsEmail()
- *   email: string;
- *
- *   @IsRequired()
- *   @MinLength(3)
- *   name: string;
- * }
- *
- * const userData = { email: 'user@example.com', name: 'John' };
- * const validated = await Validator.validateTarget(User, userData);
- * ```
- *
- * ## Advanced Usage
- * ```typescript
- * // Complex validation with context
- * const validationOptions = {
- *   value: userData,
- *   rules: [
- *     'required',
- *     { minLength: [5] },
- *     async ({ value, context }) => {
- *       const exists = await checkIfUserExists(value);
- *       return !exists || 'User already exists';
- *     }
- *   ],
- *   context: { userId: 123 }
- * };
- *
- * try {
- *   const result = await Validator.validate(validationOptions);
- *   console.log('Validation passed!', result);
- * } catch (error) {
- *   console.error('Validation failed:', error.message);
- * }
- * ```
- *
- * @author Resk Framework Team
- *
- * @version 2.1.0
- * @see {@link https://docs.resk.dev/validation | Validation Documentation}
- * @public
- */
+import { ValidatorBulkError, ValidatorClassError, ValidatorCreateBulkErrorPayload, ValidatorCreateClassErrorPayload, ValidatorCreateErrorPayload, ValidatorError } from './errors';
+import { ValidatorAsyncRuleResult, ValidatorBulkOptions, ValidatorBulkResult, ValidatorClassOptions, ValidatorClassResult, ValidatorDefaultMultiRule, ValidatorMultiRuleFunction, ValidatorMultiRuleNames, ValidatorMultiRuleOptions, ValidatorNestedRuleFunctionOptions, ValidatorObjectOptions, ValidatorObjectResult, ValidatorObjectRules, ValidatorObjectSchema, ValidatorOptions, ValidatorResult, ValidatorRule, ValidatorRuleFunction, ValidatorRuleFunctionsMap, ValidatorRuleName, ValidatorRuleObject, ValidatorRuleParams, ValidatorRuleResult, ValidatorRules, ValidatorSanitizedRuleObject, ValidatorSanitizedRules, ValidatorSuccess } from './types';
 export declare class Validator {
     private static readonly RULES_METADATA_KEY;
     /**
@@ -95,14 +23,14 @@ export declare class Validator {
      *   context?: Context;
      *   fieldName?: string;
      *   translatedPropertyName?: string;
-     * }) => ValidatorResult
+     * }) => ValidatorRuleResult
      * ```
      *
      * ### Rule Return Values
      * - `true` - Validation passed
      * - `false` - Validation failed (uses default error message)
      * - `string` - Validation failed with custom error message
-     * - `ValidatorAsyncResult` - Async validation
+     * - `ValidatorAsyncRuleResult` - Async validation
      *
      * @example
      * ```typescript
@@ -477,7 +405,7 @@ export declare class Validator {
      * console.log(separators); // { multiple: ", ", single: ", " }
      *
      * // Custom error message formatting
-     * function formatValidationErrors(fieldName: string, errors: string[]) {
+     * function formatValidatorErrors(fieldName: string, errors: string[]) {
      *   const seps = Validator.getErrorMessageSeparators();
      *   if (errors.length === 0) return null;
      *   if (errors.length === 1) return `${fieldName}: ${errors[0]}`;
@@ -485,7 +413,7 @@ export declare class Validator {
      * }
      *
      * const errors = ['Field is required', 'Must be email', 'Too short'];
-     * console.log(formatValidationErrors('email', errors));
+     * console.log(formatValidatorErrors('email', errors));
      * // Output: "email: Field is required, Must be email, Too short"
      *
      * // Using separators in validation result processing
@@ -530,13 +458,15 @@ export declare class Validator {
      *
      * @remarks
      * - Separators are loaded from i18n key `validator.separators` with fallback defaults
-     * - Method is used internally by `validate()` and `validateTarget()` for error formatting
+     * - Method is used internally by `validate()` and `validateClass()` for filtering error formatting
      * - Supports both built-in i18n and custom I18n instances
      * - Thread-safe and stateless - can be called multiple times without side effects
      * - Default separators ensure English-compatible formatting when i18n unavailable
+     * - Note: This deals specifically with flat lists of errors (e.g. multiple failed rules on one field).
+     *   Nested error structure formatting (e.g. nested objects) is handled separately via `translateNestedErrorResult`.
      *
      * @see {@link validate} - Uses these separators for formatting validation error messages
-     * @see {@link validateTarget} - Uses these separators for multi-field validation errors
+     * @see {@link validateClass} - Uses these separators for multi-field validation errors
      * @see {@link validateMultiRule} - Uses separators for OneOf/AllOf error aggregation
      * @see {@link validateArrayOfRule} - Uses separators for array item error formatting
      * @see {@link I18n} - Internationalization system for custom separator configuration
@@ -549,201 +479,95 @@ export declare class Validator {
     /**
      * ## Parse and Validate Rules
      *
-     * Core rule normalization method that converts diverse validation rule formats into a standardized,
-     * executable representation while identifying and isolating invalid rules. This method serves as
-     * the critical preprocessing step that enables flexible rule input while ensuring type safety
-     * and consistent validation behavior across the entire validator system.
+     * The primary entry point for rule preprocessing in the validation pipeline.
+     * This method bridges the gap between user-friendly rule specification and the internal validation engine.
      *
-     * ### Purpose
-     * The `parseAndValidateRules` method bridges the gap between user-friendly rule specification
-     * and the internal validation engine. It accepts rules in multiple formats (strings, objects, functions)
-     * and transforms them into a uniform structure that the validation pipeline can process efficiently.
-     * Invalid rules are separated out for error reporting rather than causing validation failures.
+     * It transforms rules from multiple formats (strings, objects, functions) into a uniform structure
+     * that the validation engine can execute. Crucially, it isolates invalid rules (e.g., misspelled names)
+     * so they can be reported separately without crashing the validation process.
      *
      * ### Supported Input Formats
      *
-     * #### 1. Function Rules (Direct Validation Functions)
+     * #### 1. Function Rules (Direct Logic)
+     * The most flexible format. Functions are preserved as-is.
      * ```typescript
-     * // Synchronous function rule
-     * const positiveRule = ({ value }) => value > 0 || 'Must be positive';
-     *
-     * // Asynchronous function rule with context
-     * const asyncRule = async ({ value, context }) => {
-     *   const result = await someAsyncCheck(value, context);
-     *   return result || 'Async validation failed';
-     * };
+     * // Synchronous
+     * const isEven = ({ value }) => value % 2 === 0 || 'Must be even';
      *
-     * // Function rules with custom error messages
-     * const customRule = ({ value }) => {
-     *   if (!value) return 'Value is required';
-     *   if (value.length < 3) return 'Must be at least 3 characters';
-     *   return true; // Valid
+     * // Asynchronous
+     * const isUnique = async ({ value, context }) => {
+     *   return await checkDb(value) || 'Already exists';
      * };
      * ```
      *
-     * #### 2. String Rules (Bracket Notation for Parameters)
+     * #### 2. String Rules (Simple Names)
+     * Useful for built-in rules that don't require parameters (or where parameters are optional).
      * ```typescript
-     * // Simple rules without parameters
-     * 'Required'                    // Basic required field check
-     * 'Email'                       // Email format validation
-     * 'IsNumber'                    // Type checking
+     * 'Required'
+     * 'Email'
+     * 'IsNumber'
+     * ```
      *
-     * // Rules with single parameter
-     * 'MinLength'               // Minimum length validation
-     * 'MaxLength'             // Maximum length validation
-     * 'GreaterThan'             // Numeric comparison
+     * #### 3. Object Rules (Type-Safe & Configurable)
+     * The most robust format, supporting parameters and custom messages.
      *
-     * // Rules with multiple parameters
-     * 'Between'             // Range validation (inclusive)
-     * 'InArray'  // Value enumeration
-     * 'Matches[/^[A-Z]{2}\d{6}$/]' // Regex pattern matching
+     * **Standard Format:**
+     * ```typescript
+     * { MinLength: [5] }           // Rule with parameters
+     * { Required: [] }             // Rule without parameters
      * ```
      *
-     * #### 3. Object Rules (Structured Parameter Passing)
+     * **Extended Format (with Custom Message):**
      * ```typescript
-     * // Rules without parameters
-     * { Required: [] }              // Explicit empty parameter array
-     * { Email: undefined }          // Undefined parameters (treated as [])
-     *
-     * // Rules with single parameter
-     * { MinLength: [5] }           // Array with one element
-     * { MaxLength: [100] }         // Array with one element
-     *
-     * // Rules with multiple parameters
-     * { Between: [10, 20] }        // Range validation
-     * { InArray: ['admin', 'user', 'guest'] }  // Multiple allowed values
-     * { CustomRule: ['param1', 'param2', 42] } // Mixed parameter types
+     * {
+     *   Required: {
+     *     params: [],
+     *     message: "This specific field is mandatory!"
+     *   }
+     * }
      * ```
      *
      * ### Processing Logic
-     * The method follows a systematic approach to rule processing:
-     *
-     * 1. **Input Validation**: Accepts `undefined`, empty arrays, or arrays of mixed rule types
-     * 2. **Function Detection**: Direct function rules are preserved unchanged in the output
-     * 3. **String Parsing**: Bracket syntax is parsed to extract rule names and parameters
-     * 4. **Object Processing**: Object notation is converted to standardized rule objects
-     * 5. **Rule Registry Lookup**: Each parsed rule is validated against the registered rules map
-     * 6. **Error Isolation**: Invalid/unregistered rules are collected separately for reporting
-     * 7. **Type Safety**: All output maintains TypeScript type safety with proper generics
+     * 1. **Normalization**: Iterates through the input array.
+     * 2. **Function Preservation**: Function rules are added directly to `sanitizedRules`.
+     * 3. **String Parsing**: String rules are looked up in the registry.
+     * 4. **Object Parsing**: Object rules are converted to `ValidatorSanitizedRuleObject`s.
+     * 5. **Validation**: Rules that are not found in the registry are moved to `invalidRules`.
      *
-     * ### Output Structure
-     * The method returns a structured result object with two key properties:
+     * ### Return Value Structure
+     * Returns an object `{ sanitizedRules, invalidRules }`.
      *
-     * #### `sanitizedRules` - Successfully Processed Rules
-     * Array of standardized rule objects with consistent structure:
-     * ```typescript
-     * interface SanitizedRule {
-     *   ruleName: ValidatorRuleName;        // Extracted rule name
-     *   params: any[];                     // Parameter array (empty for no params)
-     *   ruleFunction: ValidatorRuleFunction; // Actual validation function
-     *   rawRuleName: string;               // Original input string/object
-     * }
-     * ```
+     * - **sanitizedRules**: Array of `ValidatorSanitizedRule` (Union of functions and objects).
+     *   - Functions are untouched.
+     *   - Objects are normalized to `{ ruleName, params, ruleFunction, message? }`.
      *
-     * #### `invalidRules` - Unprocessable Rules
-     * Array of rules that couldn't be processed (maintains original input types):
-     * - Unregistered rule names
-     * - Malformed string syntax
-     * - Invalid object structures
-     * - Rules that failed registry lookup
-     *
-     * ### Error Handling Strategy
-     * - **Graceful Degradation**: Invalid rules don't break the entire validation process
-     * - **Error Reporting**: Invalid rules are collected for user feedback
-     * - **Type Preservation**: Original rule formats are maintained in invalidRules array
-     * - **Validation Continuation**: Valid rules proceed through the validation pipeline
+     * - **invalidRules**: Array of rules that failed parsing or lookup. kept in original format for error reporting.
      *
      * @example
      * ```typescript
-     * // Mixed rule formats with validation
      * const mixedRules = [
-     *   'Required',                           // String rule
-     *   { MaxLength: [50] },                 // Object rule
-     *   ({ value }) => value.includes('@') || 'Must contain @', // Function rule
-     *   'InvalidRule',                       // Will be reported as invalid
-     *   { NonExistentRule: ['param'] }       // Will be reported as invalid
+     *   'Required',                                  // String rule
+     *   { MaxLength: [50] },                        // Object rule
+     *   { MinLength: { params: [3], message: "Too short!" } }, // Custom message
+     *   ({ value }) => value.includes('@'),         // Function rule
+     *   'InvalidRule'                               // Will be invalid
      * ];
      *
      * const { sanitizedRules, invalidRules } = Validator.parseAndValidateRules(mixedRules);
      *
-     * console.log('Successfully parsed rules:', sanitizedRules.length); // 4
-     * console.log('Invalid rules found:', invalidRules.length);         // 2
-     * console.log('Invalid rules:', invalidRules);
-     * // Output: ['InvalidRule', { NonExistentRule: ['param'] }]
-     *
-     * // Each sanitized rule has consistent structure
-     * sanitizedRules.forEach(rule => {
-     *   console.log(`Rule: ${rule.ruleName}, Params: ${rule.params.length}, Raw: ${rule.rawRuleName}`);
-     * });
-     *
-     * // Empty or undefined input handling
-     * const { sanitizedRules: emptyRules } = Validator.parseAndValidateRules();
-     * console.log('Empty input rules:', emptyRules.length); // 0
-     *
-     * const { sanitizedRules: undefinedRules } = Validator.parseAndValidateRules(undefined);
-     * console.log('Undefined input rules:', undefinedRules.length); // 0
-     *
-     * // Complex validation scenarios
-     * const complexRules = [
-     *   'Between[1,100]',                    // Numeric range
-     *   { InArray: ['admin', 'user'] },      // Value enumeration
-     *   ({ value, context }) => {            // Context-aware function
-     *     if (context?.userType === 'admin') return true;
-     *     return value !== 'admin' || 'Admin access required';
-     *   }
-     * ];
-     *
-     * const result = Validator.parseAndValidateRules(complexRules);
-     * console.log('Complex rules processed:', result.sanitizedRules.length); // 3
-     * console.log('No invalid rules:', result.invalidRules.length); // 0
-     *
-     * // Error handling in validation pipeline
-     * const validationRules = ['Required', 'Email', 'UnknownRule'];
-     * const { sanitizedRules: validRules, invalidRules: errors } = Validator.parseAndValidateRules(validationRules);
-     *
-     * if (errors.length > 0) {
-     *   console.warn('Some validation rules are invalid:', errors);
-     *   // Could log to monitoring system or throw custom error
-     * }
-     *
-     * // Proceed with valid rules only
-     * const validationResult = await Validator.validate({
-     *   value: 'test@example.com',
-     *   rules: validRules.map(rule => rule.ruleFunction) // Extract functions for validation
-     * });
+     * console.log(sanitizedRules.length); // 4
+     * console.log(invalidRules.length);   // 1
      * ```
      *
-     * @template Context - Optional validation context type passed to rule functions
-     *
-     * @param inputRules - Array of validation rules in various formats, or undefined
-     *                     Supports strings, objects, and functions in any combination
-     *                     Undefined or empty arrays are handled gracefully
-     *
-     * @returns Structured result object containing processed rules and errors
-     * @returns returns.sanitizedRules - Array of successfully parsed rule objects with standardized structure
-     * @returns returns.invalidRules - Array of rules that couldn't be processed (maintains original format)
+     * @template Context - Type of the validation context
+     * @param inputRules - Array of rules (or undefined)
+     * @returns Object containing valid sanitized rules and a list of invalid rules
      *
-     * @remarks
-     * - This method is the primary entry point for rule preprocessing in the validation pipeline
-     * - Called internally by `validate()` and `validateTarget()` before rule execution
-     * - Invalid rules are isolated rather than causing validation failures for better error handling
-     * - Supports all rule formats: functions, bracket strings, and parameter objects
-     * - Maintains type safety through TypeScript generics for context propagation
-     * - Rule registry lookup ensures only registered rules are accepted
-     * - Empty input (undefined/null) returns empty arrays without errors
-     * - Processing is synchronous and performant for large rule sets
-     * - Invalid rules preserve original input format for accurate error reporting
-     *
-     * @see {@link parseStringRule} - Internal method for parsing bracket notation strings
-     * @see {@link parseObjectRule} - Internal method for processing object notation rules
-     * @see {@link validate} - Main validation method that uses this preprocessing
-     * @see {@link validateTarget} - Class-based validation that uses this preprocessing
-     * @see {@link registerRule} - Method for registering custom rules in the system
-     * @see {@link getRules} - Method to retrieve all registered rules
-     * @see {@link ValidatorSanitizedRules} - Type definition for processed rules
      * @public
+     * @see {@link parseStringRule}
+     * @see {@link parseObjectRule}
      */
-    static parseAndValidateRules<Context = unknown>(inputRules?: ValidatorValidateOptions<ValidatorDefaultArray, Context>['rules']): {
+    static parseAndValidateRules<Context = unknown>(inputRules?: ValidatorOptions<ValidatorDefaultArray, Context>['rules']): {
         sanitizedRules: ValidatorSanitizedRules<Context>;
         invalidRules: ValidatorRules<Context>[];
     };
@@ -758,11 +582,7 @@ export declare class Validator {
      * ### Current Supported String Formats
      * - `"ruleName"` - Simple rule without parameters (e.g., `"Required"`, `"Email"`)
      *
-     * ### Future Parameter Support (Currently Commented Out)
-     * The method includes commented code for bracket notation parameter parsing:
-     * - `"ruleName[param]"` - Rule with single parameter (planned)
-     * - `"ruleName[param1,param2,param3]"` - Rule with multiple parameters (planned)
-     *
+  
      * ### Processing Logic
      * 1. **Input Validation**: Accepts any value, converts to trimmed string
      * 2. **Rule Lookup**: Searches registered rules map using the string as rule name
@@ -771,9 +591,8 @@ export declare class Validator {
      * 5. **Error Handling**: Returns null if rule is not found in registry
      *
      * ### Parameter Handling
-     * - Currently no parameter parsing is performed
-     - All parameters must be provided via object notation: `{ RuleName: [params] }`
-     - Bracket notation parsing is reserved for future implementation
+     * - String rules **do not** support parameters.
+     * - Rules needing parameters must use object notation: `{ RuleName: [params] }`
      *
      * ### Return Value Structure
      * When successful, returns a complete rule object:
@@ -782,7 +601,6 @@ export declare class Validator {
      *   ruleName: "Required",           // The rule identifier
      *   params: [],                     // Empty array (no parsing yet)
      *   ruleFunction: Function,         // The actual validation function
-     *   rawRuleName: "Required"         // Original input string
      * }
      * ```
      *
@@ -797,10 +615,10 @@ export declare class Validator {
      * ```typescript
      * // Simple rule lookup
      * const rule = Validator.parseStringRule("Required", registeredRules);
-     * // Returns: { ruleName: "Required", params: [], ruleFunction: fn, rawRuleName: "Required" }
+     * // Returns: { ruleName: "Required", params: [], ruleFunction: fn }
      *
      * const emailRule = Validator.parseStringRule("Email", registeredRules);
-     * // Returns: { ruleName: "Email", params: [], ruleFunction: fn, rawRuleName: "Email" }
+     * // Returns: { ruleName: "Email", params: [], ruleFunction: fn }
      * ```
      *
      * #### Unknown Rule Handling
@@ -828,12 +646,7 @@ export declare class Validator {
      * - **Memory Efficient**: Creates minimal rule objects
      * - **Synchronous**: No async operations or I/O
      *
-     * ### Future Enhancements
-     * - Implement bracket notation parameter parsing
-     * - Support nested parameter structures
-     * - Add parameter type validation
-     * - Support quoted parameters with spaces
-     *
+  
      * @template Context - Optional validation context type for rule functions
      *
      * @param ruleString - The string representation of the rule to parse
@@ -845,13 +658,11 @@ export declare class Validator {
      * @returns returns.ruleName - The rule identifier (same as input string)
      * @returns returns.params - Empty array (parameter parsing not implemented)
      * @returns returns.ruleFunction - The actual validation function from registry
-     * @returns returns.rawRuleName - The original unparsed rule string
      *
      * @throws {Never} This method never throws errors; returns null for invalid rules
      *
      * @remarks
      * - This is an internal method used by `parseAndValidateRules`
-     * - Parameter parsing via bracket notation is planned but currently commented out
      * - For rules with parameters, use object notation: `{ RuleName: [param1, param2] }`
      * - Rule registry lookup ensures only registered rules are accepted
      * - Maintains type safety through TypeScript generics for context propagation
@@ -864,314 +675,84 @@ export declare class Validator {
      * @see {@link ValidatorSanitizedRuleObject} - Type definition for parsed rules
      */
     static parseStringRule<Context = unknown>(ruleString: string, registeredRules: ValidatorRuleFunctionsMap<Context>): any;
+    /**
+     * ## Parse Function Rule
+     *
+     * Transforms a raw validation function into a standardized rule object.
+     * This is a critical normalization step that ensures even ad-hoc, anonymous functions
+     * conform to the system's uniform `ValidatorSanitizedRuleObject` structure.
+     *
+     * ### Logic
+     * 1. **Rule Name resolution**: Attempts to identify the rule name in this order:
+     *    - Checks for a marked rule name (metadata attached via decorators)
+     *    - Falls back to the function's innate `.name` property
+     *    - Defaults to "anonymous" (implicit in most cases if un-named)
+     * 2. **Structure Creation**: Wraps the function in a standard object with:
+     *    - `ruleFunction`: The original function itself
+     *    - `ruleName`: The resolved identifier
+     *    - `params`: Empty array `[]` (Function rules carry their logic internally)
+     *
+     * @template Context - Validation context type
+     * @param rule - The raw validation function to process
+     * @returns A sanitized rule object containing the function and metadata
+     */
     static parseFunctionRule<Context = unknown>(rule: ValidatorRuleFunction<ValidatorDefaultArray, Context>): ValidatorSanitizedRuleObject<ValidatorDefaultArray, Context>;
     /**
      * ## Parse Object Rule
      *
      * Parses object notation validation rules into standardized rule objects. This method handles
-     * rules specified as key-value pairs where the key is the rule name and the value is an array
-     * of parameters. Object notation allows for more complex rule configurations with explicit
-     * parameter passing.
-     *
-     * ### Object Rule Format
-     * Object rules are specified as JavaScript objects where:
-     * - **Keys**: Rule names (strings) that correspond to registered validation functions
-     * - **Values**: Arrays of parameters to pass to the validation rule function
+     * rules specified as key-value pairs where the key is the rule name and the value is either
+     * an array of parameters or a structured configuration object.
+     *
+     * ### Object Rule Formats
+     * 1. **Simple Format**: Key is rule name, value is parameter array
+     *    ```typescript
+     *    { MinLength: [5] }
+     *    ```
+     * 2. **Detailed Format**: Key is rule name, value is object with `params` and `message`
+     *    ```typescript
+     *    {
+     *      Required: {
+     *        params: [],
+     *        message: "This field is mandatory"
+     *      }
+     *    }
+     *    ```
      *
      * ### Processing Logic
-     * 1. **Input Validation**: Ensures `rulesObject` is a valid object, returns empty array otherwise
-     * 2. **Rule Iteration**: Iterates through each property in the rules object
-     * 3. **Rule Lookup**: Checks if each rule name exists in the registered rules map
-     * 4. **Parameter Extraction**: Retrieves the parameter array for each valid rule
-     * 5. **Rule Construction**: Creates sanitized rule objects with function references and parameters
-     * 6. **Result Aggregation**: Collects all valid rules into a result array
-     *
-     * ### Parameter Requirements
-     * - Rule parameters must be arrays (e.g., `[5]` for MinLength, `[10, 100]` for range rules)
-     * - Non-array parameters are ignored (future enhancement may support other formats)
-     * - Invalid rule names (not registered) are silently skipped
-     *
-     * ### Examples
-     *
-     * #### Basic Object Rules
-     * ```typescript
-     * const rulesObject = {
-     *   Required: [],           // No parameters
-     *   MinLength: [5],         // Single parameter
-     *   MaxLength: [50],        // Single parameter
-     *   Pattern: ['^[A-Z]+$'],  // String parameter
-     * };
-     *
-     * const parsedRules = Validator.parseObjectRule(rulesObject, registeredRules);
-     * // Returns array of sanitized rule objects with function references
-     * ```
-     *
-     * #### Complex Parameter Rules
-     * ```typescript
-     * const complexRules = {
-     *   Range: [1, 100],                    // Multiple numeric parameters
-     *   CustomPattern: ['^[0-9]{3}-[0-9]{3}$'], // Regex pattern
-     *   Enum: [['active', 'inactive', 'pending']], // Array parameter
-     * };
-     * ```
-     *
-     * #### Mixed with String Rules
-     * ```typescript
-     * // Object rules are typically used alongside string rules
-     * const allRules = [
-     *   "Required",              // String rule
-     *   "Email",                 // String rule
-     *   { MinLength: [3] },      // Object rule
-     *   { MaxLength: [100] },    // Object rule
-     * ];
-     *
-     * const result = Validator.parseAndValidateRules(allRules);
-     * ```
-     *
-     * #### Integration with Validation Pipeline
-     * ```typescript
-     * // Object rules are processed during rule parsing phase
-     * const inputRules = [
-     *   "Required",
-     *   { MinLength: [5], MaxLength: [50] },
-     *   "Email"
-     * ];
-     *
-     * const { sanitizedRules } = Validator.parseAndValidateRules(inputRules);
-     * // sanitizedRules contains both string and object rule objects
-     * ```
-     *
-     * ### Error Handling
-     * - **Invalid Input**: Returns empty array if `rulesObject` is not an object
-     * - **Missing Rules**: Unregistered rule names are ignored (not added to result)
-     * - **Invalid Parameters**: Non-array parameters are ignored
-     * - **No Errors Thrown**: Method is robust and never throws exceptions
-     *
-     * ### Performance Characteristics
-     * - **Linear Time**: O(n) where n is the number of properties in rules object
-     * - **Memory Efficient**: Creates minimal objects with function references
-     * - **Registry Lookup**: Fast hash map lookup for rule function existence
-     * - **Parameter Validation**: Lightweight array type checking
-     *
-     * ### Future Enhancements
-     * - Support for non-array parameter formats (single values, objects)
-     * - Parameter type validation against rule function signatures
-     * - Rule dependency resolution and ordering
-     * - Enhanced error reporting for invalid configurations
-     *
-     * @template Context - Optional type for validation context passed to rule functions
-     *
-     * @param rulesObject - Object containing rule names as keys and parameter arrays as values
-     * @param registeredRules - Map of registered validation rule functions for lookup
-     *
-     * @returns Array of sanitized rule objects with function references and parameters
-     *          - Empty array if input is invalid or no valid rules found
-     *          - Each object contains: ruleName, ruleFunction, params, rawRuleName
-     *
-     * @throws {Never} This method never throws errors; invalid inputs return empty arrays
-     *
-     * @remarks
-     * - This method complements `parseStringRule` for different rule input formats
-     * - Object rules enable complex parameter passing not possible with string notation
-     * - Rules are validated against the registry to ensure only registered functions are used
-     * - Parameter arrays are passed directly to rule functions without modification
-     * - The method is part of the rule preprocessing pipeline in `parseAndValidateRules`
-     *
-     * @see {@link parseStringRule} - Handles string notation rules without parameters
-     * @see {@link parseAndValidateRules} - Main rule parsing method that uses this function
-     * @see {@link registerRule} - How rules are registered in the rule functions map
-     * @see {@link ValidatorRuleObject} - Type definition for object rule format
-     * @see {@link ValidatorSanitizedRuleObject} - Type definition for parsed rule objects
-     *
-     * @public
-     * @static
+     * 1. **Input Validation**: Ensures `rulesObject` is a valid object
+     * 2. **Sanitized Check**: Pass-through if object is already sanitized
+     * 3. **Iteration**: Loops through keys in the object
+     * 4. **Lookup**: Verifies rule existence in registry
+     * 5. **Extraction**: Handles both array and object value formats
+     * 6. **Construction**: Creates standardized rule objects with function references
+     *
+     * @param rulesObject - The rule configuration object
+     * @param registeredRules - Map of registered validation functions
+     * @returns Array of sanitized rule objects ready for execution
      */
     static parseObjectRule<Context = unknown>(rulesObject: ValidatorRuleObject, registeredRules: ValidatorRuleFunctionsMap<Context>): ValidatorSanitizedRuleObject<ValidatorDefaultArray, Context>[];
-    static isSanitizedRuleObject<TRuleParams extends ValidatorDefaultArray = ValidatorDefaultArray, Context = unknown>(rule: any): rule is ValidatorSanitizedRuleObject<TRuleParams, Context>;
     /**
-     * ## Validate - Core Single-Value Validation Engine
-     *
-     * Executes comprehensive validation on a single value against an array of validation rules.
-     * This method implements the core validation pipeline with sequential rule execution,
-     * multi-rule delegation, and sophisticated error handling for complex validation scenarios.
-     *
-     * ### Validation Pipeline Overview
-     * 1. **Rule Parsing**: Validates and sanitizes input rules using `parseAndValidateRules`
-     * 2. **Invalid Rule Handling**: Returns failure result for any invalid rules
-     * 3. **Nullable Skip Check**: Skips validation if value meets nullable rule conditions
-     * 4. **Sequential Execution**: Processes rules one-by-one using Promise-based `next()` function
-     * 5. **Multi-Rule Detection**: Delegates to specialized handlers for OneOf/AllOf/ArrayOf/ValidateNested
-     * 6. **Result Processing**: Handles boolean, string, and Error results with proper error creation
-     * 7. **Error Aggregation**: Returns discriminated union result (success/failure)
-     *
-     * ### Rule Execution Strategy
-     * - **Sequential Processing**: Rules execute one after another, not in parallel
-     * - **Early Exit**: Validation stops on first rule failure (fail-fast behavior)
-     * - **Rule Context**: Each rule receives i18n context, field names, and validation options
-     * - **Parameter Extraction**: Automatically extracts rule names and parameters from various formats
-     *
-     * ### Multi-Rule Support
-     * The method automatically detects and delegates to specialized validators:
-     * - **OneOf/AllOf**: Uses symbol markers to identify logical combination rules
-     * - **ArrayOf**: Validates arrays where each item must satisfy sub-rules
-     * - **ValidateNested**: Delegates to class-based validation for nested objects
-     *
-     * ### Error Handling Architecture
-     * - **Boolean Results**: `false` → creates validation error with i18n message
-     * - **String Results**: Direct error messages (validated for non-null strings)
-     * - **Error Objects**: Stringifies thrown errors and creates validation errors
-     * - **Invalid Messages**: Falls back to i18n for null/undefined string results
-     *
-     * ### Nullable Rule Behavior
-     * Skips remaining validation when nullable conditions are met:
-     * - **Empty**: Skips if value is empty string `""`
-     * - **Nullable**: Skips if value is `null` or `undefined`
-     * - **Optional**: Skips if value is `undefined` only
-     *
-     * ### Rule Format Support
-     * Accepts rules in multiple formats with automatic parameter extraction:
-     * - **String Rules**: `"Email"`, `"Required"`
-     * - **Function Rules**: Direct validator functions with optional parameters
-     * - **Object Rules**: `{ ruleFunction, params, ruleName }` structured objects
-     *
-     * ### Context Propagation
-     * Builds comprehensive context for each rule execution:
-     * - **i18n Options**: Translation keys, field names, rule information
-     * - **Validation Data**: Current value, rule parameters, context object
-     * - **Field Metadata**: Property names, translated names, data references
-     *
-     * #### Basic Usage Examples
-     * ```typescript
-     * // Simple string validation
-     * const result1 = await Validator.validate({
-     *   value: "test@example.com",
-     *   rules: ["Required", "Email"],
-     * });
-     * // result1.success === true
-     *
-     * // Numeric validation with parameters
-     * const result2 = await Validator.validate({
-     *   value: 25,
-     *   rules: ["Required", { Min: [18] }, { Max: [65] }],
-     * });
-     * // result2.success === true
-     *
-     * // Function-based validation
-     * const result3 = await Validator.validate({
-     *   value: "custom",
-     *   rules: [({ value }) => value.startsWith("prefix") || "Must start with prefix"],
-     * });
-     * // result3.success === true
-     * ```
-     *
-     * #### Nullable Rule Examples
-     * ```typescript
-     * // Empty allows skipping other rules
-     * const result1 = await Validator.validate({
-     *   value: "",
-     *   rules: ["Empty", "Email"],
-     * });
-     * // result1.success === true (skips Email check)
-     *
-     * // Nullable allows null/undefined
-     * const result2 = await Validator.validate({
-     *   value: null,
-     *   rules: ["Nullable", "IsNumber"],
-     * });
-     * // result2.success === true (skips IsNumber check)
-     *
-     * // Optional allows undefined only
-     * const result3 = await Validator.validate({
-     *   value: undefined,
-     *   rules: ["Optional"],
-     * });
-     * // result3.success === true (skips MinLength check)
-     * ```
-     *
-     * #### Multi-Rule Examples
-     * ```typescript
-     * // OneOf: email OR phone required
-     * const result1 = await Validator.validate({
-     *   value: "user@example.com",
-     *   rules: [Validator.oneOf(["Email", "PhoneNumber"])],
-     * });
-     * // result1.success === true
+     * ## Check if Object is Sanitized Rule
      *
-     * // ArrayOf: validate array items
-     * const result2 = await Validator.validate({
-     *   value: ["a@b.com", "c@d.com"],
-     *   rules: [Validator.arrayOf(["Email"])],
-     * });
-     * // result2.success === true
-     *
-     * // AllOf: must satisfy all conditions
-     * const result3 = await Validator.validate({
-     *   value: "hello",
-     *   rules: [Validator.allOf(["String", { MinLength: [3] }])],
-     * });
-     * // result3.success === true
-     * ```
-     *
-     * #### Type Guards for Result Narrowing
-     * ```typescript
-     * const result = await Validator.validate({
-     *   value: "test",
-     *   rules: ["Required"],
-     * });
+     * Type guard that determines whether a given value matches the structure of a
+     * `ValidatorSanitizedRuleObject`. This ensures that the object has all the necessary
+     * properties (ruleName, ruleFunction, params) to be safely used by the validation engine.
      *
-     * // Using type guards
-     * if (Validator.isSuccess(result)) {
-     *   // TypeScript knows result.success === true
-     *   console.log("Valid value:", result.value);
-     * } else if (Validator.isFailure(result)) {
-     *   // TypeScript knows result.success === false
-     *   console.error("Error:", result.error.message);
-     * }
-     * ```
-     *
-     * ### Technical Implementation Details
-     * - **Promise-Based Execution**: Uses recursive `next()` function for sequential processing
-     * - **Symbol-Based Detection**: Identifies multi-rules using internal symbol markers
-     * - **Context Building**: Constructs i18n and validation context for each rule
-     * - **Error Creation**: Uses `createValidationError` for consistent error objects
-     * - **Duration Tracking**: Measures validation execution time from start to finish
-     *
-     * @template Context - Optional type for the validation context object
-     *
-     * @param options - Validation options (MakeOptional<
-      ValidatorValidateOptions<ValidatorDefaultArray, Context>,
-      "i18n"
-    >)
-     * @param options.value - The value to validate (required)
-     * @param options.rules - Array of validation rules to apply
-     * @param options.context - Optional context object passed to rule functions
-     * @param options.data - Optional data object for rule context
-     * @param options.fieldName - Optional field identifier for error messages
-     * @param options.propertyName - Optional property identifier for error messages
-     * @param options.translatedPropertyName - Optional translated property name
-     * @param options.message - Optional custom error message prefix
+     * ### Type Guard Checks
+     * 1. **Is Object**: The value must be a non-null object.
+     * 2. **Has Function**: `ruleFunction` must be a callable function.
+     * 3. **Has Name**: `ruleName` must be a string.
+     * 4. **Has Parameters**: `params` must be an array.
      *
-     * @returns Promise resolving to ValidatorValidateResult<Context>
-     *          - Success: object with success=true, value, validatedAt, duration
-     *          - Failure: object with success=false, error, failedAt, duration
+     * @template TRuleParams - Parameter types for the rule
+     * @template Context - Validation context type
      *
-     * @throws {Never} This method never throws. All errors are returned in the result object.
-     *
-     *
-     * @see {@link validateTarget} - For class-based validation using decorators
-     * @see {@link registerRule} - To register custom validation rules
-     * @see {@link parseAndValidateRules} - Internal rule parsing and validation
-     * @see {@link shouldSkipValidation} - Nullable rule checking logic
-     * @see {@link validateMultiRule} - OneOf/AllOf rule implementation
-     * @see {@link validateArrayOfRule} - ArrayOf rule implementation
-     * @see {@link validateNestedRule} - ValidateNested rule implementation
-     * @see {@link ValidatorValidateResult} - Result type documentation
-     * @see {@link ValidatorValidationError} - Error details type
-     *
-     * @public
-     * @async
+     * @param rule - The value to check
+     * @returns `true` if the value matches the sanitized rule structure, `false` otherwise
      */
-    static validate<Context = unknown>({ rules, ...extra }: MakeOptional<ValidatorValidateOptions<ValidatorDefaultArray, Context>, 'i18n' | 'ruleParams'>): Promise<ValidatorValidateResult<Context>>;
+    static isSanitizedRuleObject<TRuleParams extends ValidatorDefaultArray = ValidatorDefaultArray, Context = unknown>(rule: any): rule is ValidatorSanitizedRuleObject<TRuleParams, Context>;
+    static validate<Context = unknown>({ rules, ...extra }: MakeOptional<ValidatorOptions<ValidatorDefaultArray, Context>, 'i18n' | 'ruleParams'>): Promise<ValidatorResult<Context>>;
     /**
      * ## Should Skip Validation
      *
@@ -1200,7 +781,7 @@ export declare class Validator {
      *
      *
      * @see {@link validate} - Uses this method to conditionally skip validation
-     * @see {@link validateTarget} - Also uses this method for class-based validation
+     * @see {@link validateClass} - Also uses this method for class-based validation
      * @public
      */
     static shouldSkipValidation<Context = unknown>({ value, rules, }: {
@@ -1218,7 +799,7 @@ export declare class Validator {
      * @template Context - Optional type for validation context
      * @template RulesFunctions - Array of sub-rules to evaluate
      * @param options - Multi-rule validation options
-     * @returns `ValidatorResult` (`ValidatorAsyncResult`)
+     * @returns `ValidatorRuleResult` (`ValidatorAsyncRuleResult`)
      * @example
      * const res = await Validator.validateOneOfRule({
      *   value: "user@example.com",
@@ -1228,7 +809,7 @@ export declare class Validator {
      *
      * @see {@link validateMultiRule}
      */
-    static validateOneOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorValidateMultiRuleOptions<Context, RulesFunctions>): ValidatorResult;
+    static validateOneOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorMultiRuleOptions<Context, RulesFunctions>): ValidatorRuleResult;
     /**
      * ## Validate AllOf Rule
      *
@@ -1240,7 +821,7 @@ export declare class Validator {
      * @template Context - Optional type for validation context
      * @template RulesFunctions - Array of sub-rules to evaluate
      * @param options - Multi-rule validation options
-     * @returns `ValidatorResult` (`ValidatorAsyncResult`)
+     * @returns `ValidatorRuleResult` (`ValidatorAsyncRuleResult`)
      * @example
      * const res = await Validator.validateAllOfRule({
      *   value: "hello",
@@ -1250,7 +831,7 @@ export declare class Validator {
      *
      * @see {@link validateMultiRule}
      */
-    static validateAllOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorValidateMultiRuleOptions<Context, RulesFunctions>): ValidatorResult;
+    static validateAllOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorMultiRuleOptions<Context, RulesFunctions>): ValidatorRuleResult;
     /**
      * ## Validate ArrayOf Rule
      *
@@ -1260,13 +841,13 @@ export declare class Validator {
      * - Ensures `value` is an array; otherwise returns the localized `array` error.
      * - Applies {@link validateMultiRule} with `"AllOf"` to each item using the provided `ruleParams`.
      * - Aggregates failing item messages; returns `true` when all items pass.
-     * - When any items fail, returns a localized summary using `failedForNItems`
-     *   followed by concatenated item error messages.
+     * - When any items fail, returns a localized summary using `arrayValidationFailed`
+     *   with indices of failed items, followed by detailed error messages for each item.
      *
      * @template Context - Optional type for validation context
      * @template RulesFunctions - Array of sub-rules applied to each item
      * @param options - Multi-rule validation options
-     * @returns `ValidatorResult` (`ValidatorAsyncResult`) - `true` if all items pass; otherwise an aggregated error string
+     * @returns `ValidatorRuleResult` (`ValidatorAsyncRuleResult`) - `true` if all items pass; otherwise an aggregated error string
      * @example
      * const res = await Validator.validateArrayOfRule({
      *   value: ["user@example.com", "admin@example.com"],
@@ -1275,14 +856,14 @@ export declare class Validator {
      * // res === true when every item is a valid email
      *
      */
-    static validateArrayOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorValidateMultiRuleOptions<Context, RulesFunctions>): ValidatorAsyncResult;
-    static getI18nTranslateOptions<Context = unknown>({ fieldName, propertyName, fieldLabel, translatedPropertyName, context, ...rest }: Partial<ValidatorValidateOptions<ValidatorDefaultArray, Context>>): Partial<ValidatorValidateOptions<ValidatorDefaultArray, Context>>;
+    static validateArrayOfRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(options: ValidatorMultiRuleOptions<Context, RulesFunctions>): ValidatorAsyncRuleResult;
+    static getI18nTranslateOptions<Context = unknown>({ fieldName, propertyName, fieldLabel, translatedPropertyName, context, ...rest }: Partial<ValidatorOptions<ValidatorDefaultArray, Context>>): Partial<ValidatorOptions<ValidatorDefaultArray, Context>>;
     /**
      * ## Validate Nested Rule (Core Nested Validation Executor)
      *
      * Internal rule function that validates a nested object against a class constructor with
      * validation decorators. This method is the workhorse for nested class validation, delegating
-     * to {@link validateTarget} for the actual multi-field validation logic.
+     * to {@link validateClass} for the actual multi-field validation logic.
      *
      * ### Purpose
      * This method implements the core logic for the `ValidateNested` rule, enabling validation of
@@ -1292,7 +873,7 @@ export declare class Validator {
      *
      * ### Validation Flow
      * 1. **Parameter Extraction**: Extracts the target class constructor from `ruleParams[0]`
-     * 2. **Validation**: Calls `validateTarget()` to validate the nested object against the class
+     * 2. **Validation**: Calls `validateClass()` to validate the nested object against the class
      * 3. **Error Aggregation**: Collects nested validation errors with property path information
      * 4. **Result Formatting**: Returns either `true` (success) or error message string (failure)
      *
@@ -1304,7 +885,7 @@ export declare class Validator {
      * - **Successful Validation**: Returns `true` without modification
      *
      * ### Type Parameters
-     * - `Target` - Class constructor extending ClassConstructor with validation decorators
+     * - `TClass` - Class constructor extending ClassConstructor with validation decorators
      * - `Context` - Optional validation context type passed through nested validations
      *
      * ### Return Values
@@ -1339,7 +920,7 @@ export declare class Validator {
      *
      * // When validating a User instance with an Address property,
      * // validateNestedRule is called to validate the address against the Address class
-     * const result = await Validator.validateTarget(User, {
+     * const result = await Validator.validateClass(User, {
      * data : {
      *   name: "John",
      *   address: { street: "123 Main St", postalCode: "12345" }
@@ -1347,16 +928,16 @@ export declare class Validator {
      * ```
      *
      * ### Key Features
-     * - **DRY Principle**: Reuses existing `validateTarget` logic to avoid code duplication
+     * - **DRY Principle**: Reuses existing `validateClass` logic to avoid code duplication
      * - **Error Context**: Preserves field hierarchy information in error messages
      * - **i18n Integration**: Uses translation system for localized error messages
      * - **Context Propagation**: Passes validation context through to nested validators
      * - **Timing Tracking**: Maintains duration tracking across nested validations
      *
-     * @template Target - Class constructor type (must extend ClassConstructor)
+     * @template TClass - Class constructor type (must extend ClassConstructor)
      * @template Context - Optional validation context type
      *
-     * @param options - Validation rule function options (ValidatorNestedRuleFunctionOptions<Target, Context>)
+     * @param options - Validation rule function options (ValidatorNestedRuleFunctionOptions<TClass, Context>)
      * @param options.ruleParams - Array containing the nested class constructor at index [0]
      * @param options.value - The nested object value to validate (extracted to data property)
      * @param options.data - The nested object data to validate against the target class
@@ -1367,7 +948,7 @@ export declare class Validator {
      * @param options.startTime - Optional timestamp for duration tracking
      * @param options.i18n - Optional i18n instance for error message translation
      *
-     * @returns {ValidatorAsyncResult}
+     * @returns {ValidatorAsyncRuleResult}
      * - Resolves to `true` if nested object validation succeeds
      * - Resolves to error message string if validation fails
      * - Never rejects; all errors are returned as resolution values
@@ -1377,24 +958,25 @@ export declare class Validator {
      *
      * @remarks
      * - This is an internal method primarily used by the `validateNested` factory
-     * - Accepts ValidatorNestedRuleFunctionOptions which omits validateTarget's i18n parameter
-     * - Delegates directly to validateTarget(target, options) maintaining all context
+     * - Accepts ValidatorNestedRuleFunctionOptions which omits validateClass's i18n parameter
+     * - Delegates directly to validateClass(target, options) maintaining all context
      * - Nested validation errors include property names for clear error tracing
      * - The method integrates seamlessly with the multi-rule validation system
      * - Supports recursive nesting of arbitrarily deep object structures
-     * - Performance: Delegates to validateTarget which validates fields in parallel
+     * - Performance: Delegates to validateClass which validates fields in parallel
      * - Error aggregation uses nested field paths for hierarchical clarity
      *
      *
      * @see {@link validateNested} - Factory function that creates rule functions using this method
-     * @see {@link validateTarget} - The underlying class-based validation method (accepts options with data)
+     * @see {@link validateClass} - The underlying class-based validation method (accepts options with data)
      * @see {@link ValidateNested} - Decorator that uses this method via the factory
      * @see {@link ValidatorNestedRuleFunctionOptions} - Options interface for this method
      * @see {@link buildMultiRuleDecorator} - Decorator builder for complex multi-rule scenarios
      * @internal
      * @async
      */
-    static validateNestedRule<Target extends ClassConstructor = ClassConstructor, Context = unknown>({ ruleParams, ...options }: ValidatorNestedRuleFunctionOptions<Target, Context>): ValidatorAsyncResult;
+    static validateNestedRule<TClass extends ClassConstructor = ClassConstructor, Context = unknown>({ ruleParams, ...options }: ValidatorNestedRuleFunctionOptions<TClass, Context>): ValidatorAsyncRuleResult;
+    static translateNestedErrorResult(nestedErrorResult: ValidatorClassError, customI18n?: I18n): string;
     /**
      * ## Validate Multi-Rule (OneOf / AllOf)
      *
@@ -1421,7 +1003,7 @@ export declare class Validator {
      *   parameterized rule object, or a rule function
      *
      * @param ruleName - Multi-rule mode to apply: `"OneOf"` or `"AllOf"`
-     * @param options - Validation options extending {@link ValidatorValidateMultiRuleOptions}
+     * @param options - Validation options extending {@link ValidatorMultiRuleOptions}
      * @param options.value - The value to validate against the sub-rules
      * @param options.ruleParams - Array of sub-rules to evaluate (functions or named/object rules)
      * @param options.context - Optional context passed through to each sub-rule
@@ -1432,7 +1014,7 @@ export declare class Validator {
      * @param options.translatedPropertyName - Optional localized property name for error messages
      * @param options.i18n - Optional i18n instance used to localize the error label
      *
-     * @returns ValidatorResult
+     * @returns ValidatorRuleResult
      * - `true` when validation succeeds (any sub-rule for `OneOf`, all sub-rules for `AllOf`)
      * - `string` containing aggregated error messages when validation fails
      *
@@ -1461,7 +1043,7 @@ export declare class Validator {
      * @public
      * @async
      */
-    static validateMultiRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(ruleName: ValidatorMultiRuleNames, { value, ruleParams, startTime, ...extra }: ValidatorValidateMultiRuleOptions<Context, RulesFunctions>): Promise<string | true>;
+    static validateMultiRule<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>>(ruleName: ValidatorMultiRuleNames, { value, ruleParams, startTime, ...extra }: ValidatorMultiRuleOptions<Context, RulesFunctions>): Promise<string | true>;
     /**
      * ## Create OneOf Validation Rule
      *
@@ -1684,7 +1266,7 @@ export declare class Validator {
      * ### Key Characteristics
      * - **Lazy Evaluation**: Rule parameters are captured at factory creation time
      * - **Composability**: Can be combined with other rules using OneOf, AllOf, ArrayOf
-     * - **Type Safety**: Full TypeScript support with generic Target class type
+     * - **Type Safety**: Full TypeScript support with generic TClass class type
      * - **Contextual Validation**: Supports optional validation context propagation
      * - **i18n Support**: Automatically uses i18n system for error messages
      *
@@ -1764,23 +1346,23 @@ export declare class Validator {
      * }
      *
      * // When context is provided during validation
-     * const result = await Validator.validateTarget(User, {
+     * const result = await Validator.validateClass(User, {
      *  data: userData,
      *   context: { userId: 1, isAdmin: true }
      * });
      * ```
      *
      * ### Type Parameters
-     * - `Target` - Class constructor type (extends ClassConstructor) that the nested object must satisfy
+     * - `TClass` - Class constructor type (extends ClassConstructor) that the nested object must satisfy
      * - `Context` - Optional validation context type passed through nested validations
      *
      * ### Parameters
-     * @param Target - The nested class constructor.
+     * @param TClass - The nested class constructor.
      *                     Must be a class decorated with validation rules.
      *
      * ### Returns
-     * `ValidatorRuleFunction<[target: Target], Context>` - A rule function that:
-     * - Accepts validation options with nested object data (ValidatorValidateOptions)
+     * `ValidatorRuleFunction<[target: TClass], Context>` - A rule function that:
+     * - Accepts validation options with nested object data (ValidatorOptions)
      * - Delegates to `validateNestedRule` for actual validation
      * - Returns `true` on successful nested object validation
      * - Returns error message string if any nested field validation fails
@@ -1791,8 +1373,8 @@ export declare class Validator {
      * 1. Extracts the data property from validation options
      * 2. Creates a shallow copy of the data using `Object.assign`
      * 3. Calls `validateNestedRule` with the combined parameters
-     * 4. Properly types the data as `ValidatorValidateTargetData<Target>`
-     * 5. Delegates to validateTarget via validateNestedRule which expects options.data
+     * 4. Properly types the data as `ValidatorClassInput<TClass>`
+     * 5. Delegates to validateClass via validateNestedRule which expects options.data
      *
      * ### Error Message Format
      * When nested validation fails, error messages include field-level details:
@@ -1802,7 +1384,7 @@ export declare class Validator {
      *
      * ### Performance Characteristics
      * - **Lazy Evaluation**: Parameters are captured but not executed until rule runs
-     * - **Efficient Nesting**: Reuses validateTarget's parallel field validation
+     * - **Efficient Nesting**: Reuses validateClass's parallel field validation
      * - **Memory Efficient**: Shallow copy of data prevents unnecessary object duplication
      * - **Async Optimized**: Properly awaits nested async validation rules
      *
@@ -1819,7 +1401,7 @@ export declare class Validator {
      * });
      * ```
      *
-     * @template Target - Class constructor for the nested object schema
+     * @template TClass - Class constructor for the nested object schema
      * @template Context - Optional context type for validations
      *
      * @param ruleParams - Tuple `[target]` where target is the class constructor
@@ -1861,7 +1443,7 @@ export declare class Validator {
      *   }
      * };
      *
-     * const result = await Validator.validateTarget(Person, {data:person});
+     * const result = await Validator.validateClass(Person, {data:person});
      * if (result.success) {
      *   console.log("Valid person with contact", result.data);
      * } else {
@@ -1870,292 +1452,308 @@ export declare class Validator {
      * ```
      *
      *
-     * @see {@link validateNestedRule} - The underlying validation executor that delegates to validateTarget
+     * @see {@link validateNestedRule} - The underlying validation executor that delegates to validateClass
      * @see {@link ValidateNested} - Decorator using this factory
-     * @see {@link validateTarget} - Multi-field class validation (signature: validateTarget<T, Context>(target, options))
-     * @see {@link ValidatorValidateOptions} - Validation options interface for rule functions
-     * @see {@link ValidatorValidateTargetOptions} - Target validation options interface
+     * @see {@link validateClass} - Multi-field class validation (signature: validateClass<T, Context>(target, options))
+     * @see {@link ValidatorOptions} - Validation options interface for rule functions
+     * @see {@link ValidatorClassOptions} - TClass validation options interface
      * @see {@link oneOf} - Similar factory for OneOf rule creation
      * @see {@link allOf} - Similar factory for AllOf rule creation
      * @see {@link arrayOf} - Similar factory for ArrayOf rule creation
      * @see {@link buildMultiRuleDecorator} - Decorator builder for complex rules
      * @public
      */
-    static validateNested<Target extends ClassConstructor<unknown> = ClassConstructor<unknown>, Context = unknown>(target: Target): ValidatorRuleFunction<Array<unknown>, Context>;
-    static isSuccess<Context = unknown>(result: ValidatorValidateResult<Context>): result is ValidatorValidateSuccess<Context>;
-    static isFailure<Context = unknown>(result: any): result is ValidatorValidateFailure<Context>;
+    static validateNested<TClass extends ClassConstructor<unknown> = ClassConstructor<unknown>, Context = unknown>(target: TClass): ValidatorRuleFunction<Array<unknown>, Context>;
+    static validateClass<TClass extends ClassConstructor = ClassConstructor, Context = unknown>(target: TClass, options: Omit<ValidatorClassOptions<TClass, Context>, 'i18n' | 'ruleParams'> & {
+        i18n?: I18n;
+    }): Promise<ValidatorClassResult<TClass, Context>>;
     /**
-     * ## Validate Target - Class-Based Validation
+     * ## Validate Object
      *
-     * Performs validation on all decorated properties of a class instance using decorator-based rules.
-     * This method supports complex, multi-field validation with field-level error accumulation.
+     * Validates a plain object against a set of rules without requiring a class definition.
+     * This provides a functional alternative to class-based validation, similar to libraries like Zod.
      *
-     * ### Key Features
-     * - **Decorator Support**: Uses @IsEmail(), @IsRequired(), @MinLength, etc. decorators
-     * - **Multi-FieldMeta Validation**: Validates all decorated properties in parallel
-     * - **Error Accumulation**: Collects all field validation errors into a single result
-     * - **FieldMeta Mapping**: Maps validated data back to original structure with proper types
-     * - **Internationalization**: Supports translated property names and error messages
-     * - **Custom Error Formatting**: Allows custom error message builders per field
-     * - **Async Rules**: Supports both sync and async validation rules for each field
-     * - **Type Safe**: Full TypeScript support with generic typing for class instances
-     *
-     * ### Return Type: ValidatorValidateTargetResult
-     * Returns a discriminated union that can be narrowed:
-     * ```typescript
-     * type ValidatorValidateTargetResult<T> =
-     *   | ValidatorValidateTargetSuccess<T>  // success: true
-     *   | ValidatorValidateTargetFailure<T>  // success: false
-     * ```
-     *
-     * #### Success Result (success: true)
-     * - `success`: true
-     * - `data`: Validated object data matching the class structure
-     * - `value`: undefined for target validation
-     * - `validatedAt`: ISO timestamp when validation completed
-     * - `duration`: Milliseconds elapsed during validation
-     * - `status`: "success"
-     * - `context`: Optional validation context of type Context
-     *
-     * #### Failure Result (success: false)
-     * - `success`: false
-     * - `data`: undefined for target failures
-     * - `errors`: Array of ValidatorValidationError objects, one per failed field
-     * - `failureCount`: Number of fields that failed validation
-     * - `message`: Summary message (e.g., "Validation failed for 3 fields")
-     * - `failedAt`: ISO timestamp when validation failed
-     * - `duration`: Milliseconds elapsed before failure
-     * - `status`: "error"
-     *
-     * ### Supported Decorators
-     * - `@IsRequired()` / `@IsNullable` / `@IsEmpty()` / `@IsOptional()` - Conditional rules
-     * - `@IsEmail()` / `@IsUrl` / `@IsPhoneNumber()` - Format validators
-     * - `@MinLength(3)` / `@MaxLength(50)` - Length validators
-     * - `@IsNumber()` / `@IsNonNullString()` - Type validators
-     * - `@ Length[n]` - Exact length validator
-     * - Custom decorators created with `Validator.buildPropertyDecorator()`
-     *
-     * ### Nullable Rule Behavior
-     * - **@IsEmpty()**: Skips remaining rules if value is empty string ""
-     * - **@IsNullable**: Skips remaining rules if value is null or undefined
-     * - **@IsOptional()**: Skips remaining rules if value is undefined only
-     * - **Skip if Absent**: @IsOptional() fields can be omitted from data entirely
+     * @template T - The type of data to validate
+     * @template Context - Optional validation context type
      *
-     * ### Examples
+     * @param data - The data object to validate
+     * @param rules - A map where keys are property names and values are rule definitions
+     * @param options - Optional validation configuration
+     * @returns Promise resolving to a structured validation result
      *
-     * #### Basic Class Validation
+     * @example
      * ```typescript
-     * class UserForm {
+     * const result = await Validator.validateObject(
+     *   { name: 'John', age: 25 },
+     *   { name: ['Required'], age: ['Required', 'Number'] }
+     * );
+     * ```
+     *
+     * @public
+     */
+    static validateObject<T extends object, Context = unknown>(data: T, rules: ValidatorObjectRules<T>, options?: Omit<ValidatorObjectOptions<ClassConstructor, Context>, 'data'>): Promise<ValidatorObjectResult<T, Context>>;
+    /**
+     * ## Create Object Schema
+     *
+     * Factory method that creates a reusable object schema for validation.
+     * This enables a Zod-like validation pattern: `const schema = Validator.object({...}); schema.validate(data);`
+     *
+     * @template T - The type of data to validate
+     * @template Context - Optional validation context type
+     *
+     * @param rules - A map where keys are property names and values are rule definitions
+     * @returns A `ValidatorObjectSchema` instance
+     *
+     * @example
+     * ```typescript
+     * const UserSchema = Validator.object({
+     *   email: ['Required', 'Email'],
+     *   age: ['NumberGTE[18]']
+     * });
+     *
+     * const result = await UserSchema.validate({ email: 'test@example.com', age: 20 });
+     * ```
+     *
+     * @public
+     */
+    static object<T extends object, Context = unknown>(rules: Record<keyof T | string, ValidatorRules>): ValidatorObjectSchema<T, Context>;
+    /**
+     * ## Validate Bulk
+     *
+     * Validates an array of class instances in a single batch operation, providing detailed
+     * feedback on which items passed or failed validation. This method is optimized for
+     * bulk data processing scenarios like CSV imports, batch API requests, or mass data migrations.
+     *
+     * ### Purpose
+     * Enables efficient validation of multiple data items against a class schema, with:
+     * - **Parallel validation**: All items are validated concurrently for performance
+     * - **Detailed failure tracking**: Each failed item includes its index and specific errors
+     * - **Contextual error messages**: Different messages for partial vs complete failures
+     * - **Type-safe results**: Discriminated union for success/failure handling
+     *
+     * ### Validation Behavior
+     * - **All items pass**: Returns {@link ValidatorBulkSuccess} with validated data array
+     * - **Some items fail**: Returns {@link ValidatorBulkError} with failure details
+     * - **All items fail**: Returns {@link ValidatorBulkError} with specialized message
+     * - **Invalid input**: Returns {@link ValidatorBulkError} if data is not an array
+     *
+     * ### Performance Characteristics
+     * - **Concurrent validation**: Uses `Promise.all()` for parallel processing
+     * - **Memory efficient**: Collects only failures, not all results
+     * - **Early validation**: Input type checking before processing
+     * - **Optimized for large datasets**: Suitable for thousands of items
+     *
+     * @template TClass - The class constructor type to validate against
+     * @template Context - Optional context type for validation rules
+     *
+     * @param target - The class constructor containing validation decorators
+     * @param options - Bulk validation options
+     * @param options.data - Array of data objects to validate
+     * @param options.startTime - Optional start timestamp (defaults to Date.now())
+     * @param options.context - Optional context passed to validation rules
+     * @param options.i18n - Optional i18n instance for custom translations
+     *
+     * @returns Promise resolving to {@link ValidatorBulkResult}
+     *
+     * @throws Never throws - Always returns a result object (success or error)
+     *
+     * @example
+     * ```typescript
+     * // Basic usage - User registration batch
+     * class User {
      *   @IsRequired()
      *   @IsEmail()
      *   email: string;
      *
      *   @IsRequired()
      *   @MinLength(3)
-     *   @MaxLength(50)
      *   name: string;
      *
-     *   @IsNullable
-     *   @IsNumber()
+     *   @IsOptional()
+     *   @NumberGTE(18)
      *   age?: number;
      * }
      *
-     * const result = await Validator.validateTarget(UserForm, {
-     *   email: "user@example.com",
-     *   name: "John Doe",
-     *   age: null,
-     * });
+     * const users = [
+     *   { email: 'alice@example.com', name: 'Alice', age: 25 },
+     *   { email: 'invalid-email', name: 'Bob', age: 30 },
+     *   { email: 'charlie@example.com', name: 'C', age: 17 }, // Too short, too young
+     * ];
+     *
+     * const result = await Validator.validateBulk(User, { data: users });
      *
      * if (result.success) {
-     *   console.log("Form is valid:", result.data);
+     *   console.log(`All ${result.data.length} users are valid`);
+     *   // Process valid users
+     *   await db.users.insertMany(result.data);
      * } else {
-     *   result.errors.forEach(error => {
-     *     console.error(`${error.propertyName}: ${error.message}`);
+     *   console.error(result.message);
+     *   // "Bulk validation failed: 2 of 3 items failed"
+     *
+     *   result.failures.forEach(failure => {
+     *     console.log(`Item ${failure.index}:`, failure.errors);
+     *     // Item 2: [{ field: 'email', message: '...' }]
+     *     // Item 3: [{ field: 'name', message: '...' }, { field: 'age', message: '...' }]
      *   });
      * }
      * ```
      *
-     * #### Complex Multi-FieldMeta Validation
+     * @example
      * ```typescript
-     * class ProductForm {
+     * // CSV Import with context
+     * class Product {
      *   @IsRequired()
-     *   @MinLength(3)
-     *   title: string;
+     *   name: string;
      *
-     *   @IsRequired()
      *   @IsNumber()
-     *   @NumberGT(0)
+     *   @NumberGTE(0)
      *   price: number;
      *
-     *   @IsEmpty() // Product description can be empty
-     *   @MaxLength(1000)
-     *   description?: string;
-     *
-     *   @IsOptional() // Can be omitted entirely
-     *   @IsUrl
-     *   imageUrl?: string;
+     *   @IsRequired()
+     *   @CustomRule((value, { context }) => {
+     *     // Validate against organization's catalog
+     *     return context.catalog.includes(value) || 'Invalid category';
+     *   })
+     *   category: string;
      * }
      *
-     * const result = await Validator.validateTarget(ProductForm, {
-     *   data : {
-     *  title: "Awesome Product",
-     *   price: 29.99,
-     *   description: "",
-     *   // imageUrl omitted (valid with @IsOptional())
-     *   }
-     * });
-     * ```
-     *
-     * #### Custom Error Message Building
-     * ```typescript
-     * const result = await Validator.validateTarget(UserForm, data, {
-     *   errorMessageBuilder: (translatedPropertyName, error, options) => {
-     *     // Custom format: "FieldMeta Name (validation rule): error message"
-     *     return `${translatedPropertyName} (${options.ruleName}): ${error}`;
-     *   }
-     * });
-     * ```
-     *
-     * #### Validation with Context
-     * ```typescript
-     * interface AuthContext {
-     *   userId: number;
-     *   isAdmin: boolean;
+     * interface ValidationContext {
+     *   catalog: string[];
+     *   organizationId: string;
      * }
      *
-     * class AdminAction {
-     *   @IsRequired()
-     *   action: string;
-     *
-     *   @IsRequired()
-     *   targetId: number;
-     * }
+     * const csvData = [
+     *   { name: 'Widget', price: 10, category: 'Tools' },
+     *   { name: 'Gadget', price: -5, category: 'Electronics' }, // Invalid price
+     * ];
      *
-     * const result = await Validator.validateTarget<typeof AdminAction, AuthContext>(
-     *   AdminAction,
-     *   { action: "delete", targetId: 123 },
-     *   { context: { userId: 1, isAdmin: true } }
+     * const result = await Validator.validateBulk<typeof Product, ValidationContext>(
+     *   Product,
+     *   {
+     *     data: csvData,
+     *     context: {
+     *       catalog: ['Tools', 'Electronics', 'Home'],
+     *       organizationId: 'org-123'
+     *     }
+     *   }
      * );
      * ```
      *
-     * #### Error Handling
+     * @example
      * ```typescript
-     * const result = await Validator.validateTarget(UserForm, {data:userData});
+     * // API endpoint - Batch user creation
+     * app.post('/api/users/batch', async (req, res) => {
+     *   const result = await Validator.validateBulk(User, {
+     *     data: req.body.users
+     *   });
      *
-     * if (!result.success) {
-     *   // Access failure details
-     *   console.log(`${result.failureCount} fields failed validation`);
-     *   console.log(result.message); // "Validation failed for 2 fields"
-     *
-     *   result.errors.forEach(error => {
-     *     console.error({
-     *       field: error.propertyName,
-     *       message: error.message,
-     *       rule: error.ruleName,
-     *       value: error.value,
+     *   if (result.success) {
+     *     const created = await db.users.insertMany(result.data);
+     *     res.json({
+     *       success: true,
+     *       count: created.length,
+     *       message: `Successfully created ${created.length} users`
      *     });
-     *   });
-     * }
+     *   } else {
+     *     res.status(400).json({
+     *       success: false,
+     *       message: result.message,
+     *       failureCount: result.failureCount,
+     *       totalCount: result.totalCount,
+     *       failures: result.failures.map(f => ({
+     *         index: f.index,
+     *         errors: f.errors.map(e => ({
+     *           field: e.field,
+     *           message: e.message
+     *         }))
+     *       }))
+     *     });
+     *   }
+     * });
      * ```
      *
-     * #### Type Guards
+     * @example
      * ```typescript
-     * const result = await Validator.validateTarget(UserForm, {data});
+     * // Error handling patterns
+     * const result = await Validator.validateBulk(User, { data: users });
      *
+     * // Pattern 1: Type narrowing with if/else
      * if (result.success) {
-     *   // result.data is properly typed
-     *   const validatedUser: Partial<UserForm> = result.data;
+     *   // TypeScript knows: result is ValidatorBulkSuccess
+     *   result.data.forEach(user => processUser(user));
      * } else {
-     *   // result.errors is available
-     *   const errorCount = result.errors.length;
+     *   // TypeScript knows: result is ValidatorBulkError
+     *   logErrors(result.failures);
      * }
-     * ```
-     *
-     * ### Signature
-     * ```typescript
-     * static async validateTarget<
-     *   Target extends ClassConstructor = ClassConstructor,
-     *   Context = unknown,
-     * >(
-     *   target: Target,
-     *   options: Omit<ValidatorValidateTargetOptions<Target, Context>, "i18n"> & {
-     *     i18n?: I18n;
-     *   }
-     * ): Promise<ValidatorValidateTargetResult<Context>>
-     * ```
      *
-     * ### Method Parameters
-     * The method accepts two parameters:
-     * 1. `target` - Class constructor decorated with validation rules
-     * 2. `options` - Configuration object containing validation data and settings
+     * // Pattern 2: Using type guards
+     * if (Validator.isSuccess(result)) {
+     *   return result.data;
+     * }
      *
-     * ### Options Structure
-     * The `options` parameter extends `ValidatorValidateTargetOptions` and includes:
-     * - `data`: Object containing property values to validate (can be partial)
-     * - `context`: Optional context object passed to all validation rules
-     * - `errorMessageBuilder`: Optional custom error message formatter function
-     *   - Signature: `(translatedPropertyName: string, error: string, options?: any) => string`
-     *   - Default: `(name, error) => \"[${name}] : ${error}\"`
-     * - `i18n`: Optional I18n instance (merged with default i18n if not provided)
-     * - Other properties from ValidatorValidateTargetOptions
+     * // Pattern 3: Extracting valid items
+     * const validIndices = new Set(
+     *   result.success ?
+     *     result.data.map((_, i) => i) :
+     *     users.map((_, i) => i).filter(i =>
+     *       !result.failures.some(f => f.index === i + 1)
+     *     )
+     * );
+     * ```
      *
-     * ### Usage Examples
+     * @example
      * ```typescript
-     * // Simple validation with data object
-     * const result = await Validator.validateTarget(UserForm, {
-     *   data: { email: \"test@example.com\", name: \"John\" },
-     *   context: { userId: 123 }
-     * });
+     * // Handling different failure scenarios
+     * const result = await Validator.validateBulk(User, { data: users });
      *
-     * // With custom error formatting
-     * const result = await Validator.validateTarget(UserForm, {
-     *   data: { email: \"test@example.com\", name: \"John\" },
-     *   errorMessageBuilder: (name, error) => `FieldMeta ${name}: ${error}`
-     * });
+     * if (!result.success) {
+     *   const { failureCount, totalCount } = result;
+     *
+     *   if (failureCount === totalCount) {
+     *     // All items failed
+     *     console.error('Complete validation failure');
+     *     // Message: "All 10 items failed validation"
+     *   } else if (failureCount === 1) {
+     *     // Single item failed
+     *     console.warn('One item failed validation');
+     *     // Message: "Bulk validation failed: 1 of 10 items failed"
+     *   } else {
+     *     // Partial failure
+     *     const successRate = ((totalCount - failureCount) / totalCount * 100).toFixed(1);
+     *     console.warn(`${successRate}% success rate`);
+     *     // Message: "Bulk validation failed: 3 of 10 items failed"
+     *   }
+     * }
      * ```
      *
-     * @template Target - Class constructor type (extends ClassConstructor)\n   * @template Context - Optional type for validation context passed to rules
-     *
-     * @param target - Class constructor decorated with validation decorators (e.g., UserForm)
-     * @param options - Validation options object\n   *                Extended from ValidatorValidateTargetOptions with optional i18n property\n   *                Type: Omit<ValidatorValidateTargetOptions<Target, Context>, \"i18n\"> & { i18n?: I18n }
-     * @param options.data - Object containing property values to validate (can be partial, required)
-     * @param options.context - Optional context object passed to all validation rules
-     * @param options.errorMessageBuilder - Optional custom error message formatter function
-     * @param options.i18n - Optional i18n instance for localization
+     * ### Common Use Cases
+     * - **CSV/Excel imports**: Validate uploaded file data before insertion
+     * - **Batch API endpoints**: Validate multiple items in a single request
+     * - **Data migrations**: Validate data before moving between systems
+     * - **Form arrays**: Validate dynamic form fields (e.g., multiple addresses)
+     * - **Bulk updates**: Validate changes before applying to database
      *
-     * @returns Promise<ValidatorValidateTargetResult<Context>>
-     * - **Success**: object with success=true, data (validated object), validatedAt, duration, status=\"success\"
-     * - **Failure**: object with success=false, errors (array), failureCount, message, failedAt, duration, status=\"error\"
-     * - Never throws; all errors are returned in the result object
+     * ### Error Message Localization
+     * The method uses contextual i18n keys for different scenarios:
+     * - `validator.invalidBulkData`: When input is not an array
+     * - `validator.bulkValidationFailed`: When some items fail (with pluralization)
+     * - `validator.bulkValidationAllFailed`: When all items fail (with pluralization)
      *
-     * @throws {Never} This method never throws. All errors are returned in the result object.
-     *
-     * @remarks
-     * - Validation is performed in parallel for all decorated fields using Promise.all()
-     * - Fields decorated with @IsOptional() can be omitted entirely from input data\n   * - Nullable/Empty rules prevent other rules from executing for that field
-     * - Property names are translated using i18n if available (via i18n.translateTarget method)
-     * - Errors include field-specific information: propertyName, translatedPropertyName, message, ruleName, value
-     * - Custom errorMessageBuilder allows field-level error message customization
-     * - Context is propagated through to all field validation rules
-     * - Supports nested validation through @ValidateNested rule and validateNested factory
-     * - Error messages use default format: \"[translatedPropertyName] : error\" unless custom builder provided
-     * - Integrates with the multi-rule system (OneOf, AllOf, ArrayOf) for field validation
-     *
-     *
-     * @see {@link validate} - For single-value validation without class schema
-     * @see {@link validateNestedRule} - Internal rule handler that delegates to validateTarget
-     * @see {@link validateNested} - Factory creating nested validation rule functions
-     * @see {@link buildPropertyDecorator} - To create custom validation decorators
-     * @see {@link registerRule} - To register custom validation rules\n   * @see {@link ValidatorValidateTargetResult} - Result type documentation
-     * @see {@link ValidatorValidationError} - Error details type
-     * @see {@link ValidatorValidateTargetOptions} - Full options interface
+     * ### Performance Tips
+     * - **Large datasets**: Consider chunking (e.g., 1000 items per batch)
+     * - **Complex validations**: Use context to cache expensive lookups
+     * - **Memory constraints**: Process results incrementally, don't accumulate all
+     * - **Progress tracking**: Wrap in a progress indicator for user feedback
      *
+     * @see {@link ValidatorBulkResult} - Return type documentation
+     * @see {@link ValidatorBulkSuccess} - Success result structure
+     * @see {@link ValidatorBulkError} - Error result structure
+     * @see {@link ValidatorBulkOptions} - Options interface
+     * @see {@link validateClass} - Single-item validation method
      * @public
-     * @async
+     * @since 1.2.0
      */
-    static validateTarget<Target extends ClassConstructor = ClassConstructor, Context = unknown>(target: Target, options: Omit<ValidatorValidateTargetOptions<Target, Context>, 'i18n' | 'ruleParams'> & {
-        i18n?: I18n;
-    }): Promise<ValidatorValidateTargetResult<Context>>;
+    static validateBulk<TClass extends ClassConstructor = ClassConstructor, Context = unknown>(target: TClass, { data, startTime, ...options }: ValidatorBulkOptions<TClass, Context>): Promise<ValidatorBulkResult<TClass, Context>>;
     /**
      * ## Extract Validation Rules from Class
      *
@@ -2192,7 +1790,7 @@ export declare class Validator {
      * }
      *
      * // Extract validation rules
-     * const rules = Validator.getTargetRules(User);
+     * const rules = Validator.getClassRules(User);
      * console.log(rules);
      * // Output:
      * // {
@@ -2207,7 +1805,7 @@ export declare class Validator {
      *
      * // Programmatic rule inspection
      * function analyzeClass(targetClass: any) {
-     *   const rules = Validator.getTargetRules(targetClass);
+     *   const rules = Validator.getClassRules(targetClass);
      *   const analysis = {
      *     totalProperties: Object.keys(rules).length,
      *     requiredProperties: [],
@@ -2233,17 +1831,17 @@ export declare class Validator {
      * @returns Record mapping property names to their validation rules
      *
      *
-     * @see {@link validateTarget} - Uses this method to get validation rules
+     * @see {@link validateClass} - Uses this method to get validation rules
      * @see {@link buildPropertyDecorator} - How rules are attached to properties
      * @public
      */
-    static getTargetRules<T extends ClassConstructor>(target: T): Record<keyof InstanceType<T>, ValidatorRule[]>;
+    static getClassRules<T = unknown>(target: T): Record<string, ValidatorRule[]>;
     /**
-     * ## Get Target Validation Options
+     * ## Get TClass Validation Options
      *
      * Retrieves validation options that have been configured for a specific class
-     * through the `@ValidationTargetOptions` decorator. These options control how
-     * validation behaves when `validateTarget` is called on the class.
+     * through the `@ValidationClassOptions` decorator. These options control how
+     * validation behaves when `validateClass` is called on the class.
      *
      * ### Configuration Options
      * Options can include custom error message builders, validation contexts,
@@ -2253,7 +1851,7 @@ export declare class Validator {
      * @example
      * ```typescript
      * // Class with custom validation options
-     * @ValidationTargetOptions({
+     * @ValidationClassOptions({
      *   errorMessageBuilder: (translatedName, error) => {
      *     return `❌ ${translatedName}: ${error}`;
      *   }
@@ -2265,11 +1863,11 @@ export declare class Validator {
      * }
      *
      * // Get the configured options
-     * const options = Validator.getValidateTargetOptions(CustomUser);
+     * const options = Validator.getValidatorClassOptions(CustomUser);
      * console.log(typeof options.errorMessageBuilder); // 'function'
      *
      * // These options will be automatically used when validating
-     * const result = await Validator.validateTarget(CustomUser, userData);
+     * const result = await Validator.validateClass(CustomUser, userData);
      * // Error messages will use the custom format
      * ```
      *
@@ -2280,11 +1878,11 @@ export declare class Validator {
      * @returns Validation options object, or empty object if none configured
      *
      *
-     * @see {@link validateTarget} - Uses these options during validation
-     * @see {@link ValidationTargetOptions} - Decorator to set these options
+     * @see {@link validateClass} - Uses these options during validation
+     * @see {@link ValidationClassOptions} - Decorator to set these options
      * @public
      */
-    static getValidateTargetOptions<T extends ClassConstructor>(target: T): ValidatorValidateTargetOptions<T, any>;
+    static getValidatorClassOptions<T = any>(target: T): ValidatorClassOptions<any, any>;
     /**
      * ## Build Rule Decorator Factory
      *
@@ -2577,7 +2175,7 @@ export declare class Validator {
      * - Rule functions are reused across multiple property applications
      *
      * #### Runtime Performance
-     * - Validation execution is deferred until `validateTarget()` is called
+     * - Validation execution is deferred until `validateClass()` is called
      * - Parameter binding happens during decoration, not validation
      * - No reflection overhead during actual validation
      *
@@ -2631,7 +2229,7 @@ export declare class Validator {
      *
      * #### Context Propagation
      * ```typescript
-     * const result = await Validator.validateTarget(UserClass, {
+     * const result = await Validator.validateClass(UserClass, {
      *   data: userData,
      *   context: { userId: 123, permissions: ['read'] },
      *   errorMessageBuilder: (field, error) => `${field}: ${error}`
@@ -2719,13 +2317,13 @@ export declare class Validator {
      * - Wrap single parameters: `[value]` instead of `value`
      *
      * #### Async rule not working
-     * - Ensure `validateTarget()` is called with `await`
+     * - Ensure `validateClass()` is called with `await`
      * - Check that validation context includes required services
      * - Verify async rule returns Promise<string | false | undefined>
      *
      * ### Related Methods
      *
-     * - {@link buildTargetRuleDecorator} - Specialized for nested class validation
+     * - {@link buildClassRuleDecorator} - Specialized for nested class validation
      * - {@link buildPropertyDecorator} - Low-level decorator creation
      * - {@link buildMultiRuleDecorator} - For rules with multiple validation functions
      *
@@ -2733,7 +2331,7 @@ export declare class Validator {
      *
      * - {@link ValidatorTupleAllowsEmpty} - Type for conditional parameter optionality
      * - {@link ValidatorRuleFunction} - Rule function interface
-     * - {@link validateTarget} - Main validation execution method
+     * - {@link validateClass} - Main validation execution method
      * - {@link ValidationOptions} - Complete validation context interface
      *
      * @template TRuleParams - Tuple type defining the exact parameter structure for the rule.
@@ -2821,34 +2419,123 @@ export declare class Validator {
      * @since 1.0.0
      * @public
      * @category Decorator Factories
-     * @see {@link buildTargetRuleDecorator}
+     * @see {@link buildClassRuleDecorator}
      * @see {@link ValidatorRuleFunction}
      * @see {@link ValidatorTupleAllowsEmpty}
      */
     static buildRuleDecorator<TRuleParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown>(ruleFunction: ValidatorRuleFunction<TRuleParams, Context>, ruleName?: ValidatorRuleName, symbolMarker?: symbol): (...ruleParameters: TRuleParams) => PropertyDecorator;
+    static isSuccess<Context = unknown>(result: ValidatorResult<Context>): result is ValidatorSuccess<Context>;
+    /**
+     * ## Get Base Error Properties
+     *
+     * Helper method that constructs the foundational properties shared by all validation errors.
+     * This ensures consistency across different error types (single, target, bulk) by centralizing
+     * the creation of timestamp, duration, status code, and error identification fields.
+     *
+     * @param options.startTime - The timestamp when validation started (for duration calculation)
+     * @returns An object containing common error fields (success status, error codes, timings)
+     * @private
+     */
+    private static getBaseError;
+    /**
+     * ## Check Base Error Structure
+     *
+     * Type guard that verifies if an unknown value matches the structure of a `ValidatorBaseError`.
+     * Checks for specific marker properties and error codes that all validation errors inherit.
+     *
+     * @param value - The value to check
+     * @returns `true` if it's a validation error base structure
+     * @private
+     */
+    private static isBaseError;
+    /**
+     * ## Create Single Validation Error
+     *
+     * Factory method for creating a `ValidatorError`.
+     * Represents a failure in a simple, single-value validation context.
+     *
+     * @param message - Human-readable error message
+     * @param details - Contextual details (value, startTime, etc.)
+     * @returns A structured `ValidatorError` object
+     */
+    static createError(message: string, details: ValidatorCreateErrorPayload): ValidatorError;
+    /**
+     * ## Create TClass Validation Error
+     *
+     * Factory method for creating a `ValidatorClassError`.
+     * Represents a failure when validating a class instance or complex object target,
+     * containing a map of field-specific errors.
+     *
+     * @param message - General summary message
+     * @param details - Context including the `errors` map for specific fields
+     * @returns A structured `ValidatorClassError` object
+     */
+    static createClassError(message: string, details: ValidatorCreateClassErrorPayload): ValidatorClassError;
+    /**
+     * ## Create Bulk Validation Error
+     *
+     * Factory method for creating a `ValidatorBulkError`.
+     * Represents a failure when validating an array of items, mapping indices to specific errors.
+     *
+     * @template TClass - The Target class type
+     * @param message - General summary message
+     * @param details - Context including the `errors` map (index -> error)
+     * @returns A structured `ValidatorBulkError` object
+     */
+    static createBulkError<TClass extends ClassConstructor = ClassConstructor>(message: string, details: ValidatorCreateBulkErrorPayload): ValidatorBulkError<TClass>;
+    /**
+     * ## Check for Single Validation Error
+     *
+     * Type guard to determine if a result is specifically a `ValidatorError`.
+     * Useful for distinguishing between simple value errors and complex target/bulk errors.
+     *
+     * @param result - The value to check
+     * @returns `true` if it's a single value validation error
+     */
+    static isError(result: unknown): result is ValidatorError;
+    /**
+     * ## Check for TClass Validation Error
+     *
+     * Type guard to determine if a result is a `ValidatorClassError`.
+     * Identifies errors resulting from class/object validation (e.g., `validateClass`).
+     *
+     * @param result - The value to check
+     * @returns `true` if it's a target object validation error
+     */
+    static isClassError(result: unknown): result is ValidatorClassError;
+    /**
+     * ## Check for Bulk Validation Error
+     *
+     * Type guard to determine if a result is a `ValidatorBulkError`.
+     * Identifies errors resulting from array bulk validation.
+     *
+     * @param result - The value to check
+     * @returns `true` if it's a bulk validation error
+     */
+    static isBulkError(result: unknown): result is ValidatorBulkError;
     private static _prepareRuleDecorator;
     private static _buildRuleDecorator;
     /**
-     * ## Build Target Rule Decorator Factory
+     * ## Build TClass Rule Decorator Factory
      *
      * Creates a specialized decorator factory for validation rules that target nested class
      * objects. This method wraps buildRuleDecorator with type specialization for target-based
      * rules like @ValidateNested.
      *
      * ### Purpose
-     * Target rule decorators validate properties by delegating to another class's validation
+     * TClass rule decorators validate properties by delegating to another class's validation
      * schema. The most common example is @ValidateNested, which validates nested objects
      * against a separate decorated class.
      *
      * ### How It Works
-     * 1. Takes a rule function specialized for target parameters: [TargetClass]
+     * 1. Takes a rule function specialized for target parameters: [targetClass]
      * 2. Wraps it using buildRuleDecorator to create a decorator factory
      * 3. Returns a decorator factory that accepts the target class constructor
      * 4. When the decorator is applied to a property, it triggers target-based validation
      * 5. The rule function receives the target class constructor in ruleParams[0]
      *
      * ### Type Parameters
-     * - Target: The nested class constructor type (defaults to ClassConstructor)
+     * - TClass: The nested class constructor type (defaults to ClassConstructor)
      *   - Must be a valid TypeScript class constructor
      *   - Can have any validation decorators
      *   - Example: Address, Contact, Location
@@ -2863,7 +2550,7 @@ export declare class Validator {
      * ```typescript
      * {
      *   value: any;                          // The property value being validated
-     *   ruleParams: [TargetClass];           // Single-element array with target constructor
+     *   ruleParams: [targetClass];           // Single-element array with target constructor
      *   context?: Context;                   // Validation context (if provided)
      *   fieldName: string;                   // Property name
      *   translatedPropertyName: string;      // Localized property name
@@ -2875,16 +2562,16 @@ export declare class Validator {
      * ```typescript
      * // Create a target-based validation rule
      * const validateNestedRule = ({ value, ruleParams, context }) => {
-     *   const [TargetClass] = ruleParams;
-     *   // Validate value against TargetClass schema
-     *   return Validator.validateTarget(TargetClass, {
+     *   const [targetClass] = ruleParams;
+     *   // Validate value against targetClass schema
+     *   return Validator.validateClass(targetClass, {
      *     data: value,
      *     context: context
      *   });
      * };
      *
      * // Create a target rule decorator
-     * const ValidateNested = Validator.buildTargetRuleDecorator(validateNestedRule);
+     * const ValidateNested = Validator.buildClassRuleDecorator(validateNestedRule);
      *
      * // Use the decorator with a target class
      * class Address {
@@ -2933,7 +2620,7 @@ export declare class Validator {
      * }
      *
      * // Validate with context
-     * const result = await Validator.validateTarget(Event, {
+     * const result = await Validator.validateClass(Event, {
      *   data: eventData,
      *   context: { userId: 123, permissions: ['edit'] },
      *   errorMessageBuilder: (fieldName, error) => `${fieldName}: ${error}`
@@ -2949,15 +2636,15 @@ export declare class Validator {
      * - Examples: @MinLength([5]), @IsEmail()([]), @Pattern([/regex/])
      * - Rule params can be any values
      *
-     * **buildTargetRuleDecorator (Specialized):**
-     * - Accepts specifically [TargetClass] as ruleParams
+     * **buildClassRuleDecorator (Specialized):**
+     * - Accepts specifically [targetClass] as ruleParams
      * - Used for class-level nested validation
      * - Examples: @ValidateNested(Address), custom target validators
      * - Rule params must contain a class constructor
      *
      * ### Implementation Details
      * This method is a thin wrapper around buildRuleDecorator that:
-     * - Specializes the TRuleParams to [target: Target]
+     * - Specializes the TRuleParams to [target: TClass]
      * - Maintains type safety for target-based rules
      * - Delegates all decorator factory logic to buildRuleDecorator
      * - Reduces code duplication while providing specialized typing
@@ -2965,7 +2652,7 @@ export declare class Validator {
      * ### Performance Characteristics
      * - No additional overhead vs buildRuleDecorator
      * - Wrapper instantiation happens at decoration time, not at import
-     * - Actual validation is performed lazily during validateTarget() calls
+     * - Actual validation is performed lazily during validateClass() calls
      * - Multiple properties with same target class share no cached state
      *
      * ### Error Handling
@@ -2982,7 +2669,7 @@ export declare class Validator {
      * - Context is propagated through nested validation layers
      * - I18n support for error messages
      *
-     * @template Target - Class constructor type for the target/nested class
+     * @template TClass - Class constructor type for the target/nested class
      *   - Extends ClassConstructor (default generic class constructor)
      *   - Must be a class decorated with validation rules
      *   - Example types: typeof Address, typeof Contact, typeof Location
@@ -2993,7 +2680,7 @@ export declare class Validator {
      *   - Can include permissions, user info, environmental data, etc.
      *
      * @param ruleFunction - The target validation rule function to wrap
-     *   - Must accept ruleParams in format [TargetClass]
+     *   - Must accept ruleParams in format [targetClass]
      *   - Called by the decorator with target class as first param element
      *   - Should return validation result or error message
      *   - Can be synchronous or asynchronous
@@ -3004,17 +2691,17 @@ export declare class Validator {
      *   - Accepts the target class constructor
      *   - Returns a property decorator
      *   - Attaches target-based validation to class properties
-     *   - Works with class validation via validateTarget()
+     *   - Works with class validation via validateClass()
      *
      *
      * @see {@link buildRuleDecorator} - General-purpose decorator factory
      * @see {@link buildPropertyDecorator} - Low-level decorator creation
      * @see {@link ValidateNested} - Example target rule decorator
      * @see {@link validateNestedRule} - Example target validation rule
-     * @see {@link validateTarget} - Parent validation method using target rules
+     * @see {@link validateClass} - Parent validation method using target rules
      * @public
      */
-    static buildTargetRuleDecorator<Target extends ClassConstructor = ClassConstructor, Context = unknown>(ruleFunction: ValidatorRuleFunction<[target: Target], Context>, symbolMarker?: symbol): (target: Target) => PropertyDecorator;
+    static buildClassRuleDecorator<TClass extends ClassConstructor = ClassConstructor, Context = unknown>(ruleFunction: ValidatorRuleFunction<[target: TClass], Context>, symbolMarker?: symbol): (target: TClass) => PropertyDecorator;
     /**
      * ## Build Multi-Rule Decorator Factory
      *
@@ -3221,7 +2908,7 @@ export declare class Validator {
      *   - Accepts an array of validation rules as parameters
      *   - Returns a property decorator when called
      *   - Attaches multi-rule validation to class properties
-     *   - Works with class validation via `validateTarget()`
+     *   - Works with class validation via `validateClass()`
      *   - Enables complex validation logic through rule composition
      *
      * @example
@@ -3249,14 +2936,14 @@ export declare class Validator {
      * }
      *
      * // Validate with context
-     * const result = await Validator.validateTarget(Contact, {
+     * const result = await Validator.validateClass(Contact, {
      *   data: { primaryContact: "user@example.com", secondaryContact: "" },
      *   context: { allowEmptySecondary: true }
      * });
      * ```
      *
      * @see {@link buildRuleDecorator} - General-purpose decorator factory
-     * @see {@link buildTargetRuleDecorator} - For nested class validation
+     * @see {@link buildClassRuleDecorator} - For nested class validation
      * @see {@link buildPropertyDecorator} - Low-level decorator creation
      * @see {@link OneOf} - Example OneOf multi-rule decorator
      * @see {@link AllOf} - Example AllOf multi-rule decorator
@@ -3277,7 +2964,7 @@ export declare class Validator {
      * ### Purpose
      * This is the most fundamental decorator factory in the validation system. It creates property
      * decorators that store validation rules as metadata on class properties, enabling the
-     * {@link validateTarget} method to discover and execute validation rules during class-based
+     * {@link validateClass} method to discover and execute validation rules during class-based
      * validation. Unlike higher-level factories, this method works directly with rule objects
      * and metadata storage.
      *
@@ -3286,7 +2973,7 @@ export declare class Validator {
      * 2. Uses the imported `buildPropertyDecorator` helper to create a property decorator
      * 3. Stores rules under the `VALIDATOR_TARGET_RULES_METADATA_KEY` symbol
      * 4. When applied to a property, accumulates rules with existing rules on the same property
-     * 5. Enables rule discovery during `validateTarget()` execution
+     * 5. Enables rule discovery during `validateClass()` execution
      *
      * ### Rule Accumulation Logic
      * The decorator accumulates rules rather than replacing them:
@@ -3455,14 +3142,14 @@ export declare class Validator {
      * - **Accumulation**: Efficient array concatenation for multiple decorators
      *
      * ### Error Handling
-     * - **Invalid rules**: Stored as-is (validation errors occur during `validateTarget`)
+     * - **Invalid rules**: Stored as-is (validation errors occur during `validateClass`)
      * - **Metadata failures**: Falls back gracefully if Reflect Metadata unavailable
      * - **Type mismatches**: TypeScript prevents invalid rule types at compile time
      * - **Runtime errors**: Handled during validation, not decoration
      *
      * ### Integration with Validation System
      * - **Metadata discovery**: Rules found by `getDecoratedProperties()` during validation
-     * - **Parallel execution**: All property rules validated simultaneously in `validateTarget()`
+     * - **Parallel execution**: All property rules validated simultaneously in `validateClass()`
      * - **Error aggregation**: Property-level errors collected with field names
      * - **Context propagation**: Validation context passed to all rule functions
      * - **i18n support**: Error messages localized through validation system
@@ -3488,7 +3175,7 @@ export declare class Validator {
      *   - Attaches the specified rule(s) to class properties
      *   - Accumulates rules when multiple decorators applied
      *   - Stores rules as metadata for validation discovery
-     *   - Works with `validateTarget()` for class validation
+     *   - Works with `validateClass()` for class validation
      *   - Enables type-safe property-level validation
      *
      * @example
@@ -3516,7 +3203,7 @@ export declare class Validator {
      * }
      *
      * // Validate the class
-     * const result = await Validator.validateTarget(User, {
+     * const result = await Validator.validateClass(User, {
      *   data: {
      *     name: "John",
      *     email: "john@example.com",
@@ -3529,8 +3216,8 @@ export declare class Validator {
      *
      * @see {@link buildRuleDecorator} - Higher-level decorator factory with parameter handling
      * @see {@link buildMultiRuleDecorator} - For multi-rule validation patterns
-     * @see {@link buildTargetRuleDecorator} - For nested class validation
-     * @see {@link validateTarget} - Class validation method that uses these decorators
+     * @see {@link buildClassRuleDecorator} - For nested class validation
+     * @see {@link validateClass} - Class validation method that uses these decorators
      * @see {@link getDecoratedProperties} - Metadata discovery for validation
      * @see {@link ValidatorRule} - Rule type attached by this decorator
      * @see {@link VALIDATOR_TARGET_RULES_METADATA_KEY} - Metadata key for rule storage
@@ -3539,11 +3226,11 @@ export declare class Validator {
     static buildPropertyDecorator<TRuleParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown>(rule: BuildPropertyDecorator<TRuleParams, Context> | BuildPropertyDecorator<TRuleParams, Context>[]): PropertyDecorator;
 }
 /**
- * ## ValidationTargetOptions Class Decorator
+ * ## ValidationClassOptions Class Decorator
  *
  * Class decorator that configures validation behavior for a target class.
  * This decorator allows you to set class-level validation options that will
- * be automatically applied whenever `validateTarget` is called on the class.
+ * be automatically applied whenever `validateClass` is called on the class.
  *
  * ### Configuration Options
  * - **errorMessageBuilder**: Custom function to format validation error messages
@@ -3559,7 +3246,7 @@ export declare class Validator {
  * @example
  * ```typescript
  * // Basic usage with custom error formatting
- * @ValidationTargetOptions({
+ * @ValidationClassOptions({
  *   errorMessageBuilder: (fieldName, error) => {
  *     return `🚫 ${fieldName.toUpperCase()}: ${error}`;
  * // {
@@ -3579,7 +3266,7 @@ export declare class Validator {
  * // "🚫 NAME: Must be at least 3 characters"
  *
  * // Advanced usage with context and detailed formatting
- * @ValidationTargetOptions({
+ * @ValidationClassOptions({
  *   errorMessageBuilder: (translatedName, error, builderOptions) => {
  *     const { propertyName, ruleName, separators } = builderOptions;
  *
@@ -3613,7 +3300,7 @@ export declare class Validator {
  *   organizationId: string;
  * }
  *
- * @ValidationTargetOptions({
+ * @ValidationClassOptions({
  *   errorMessageBuilder: (fieldName, error, { context }) => {
  *     const userContext = context as UserValidationContext;
  *     if (userContext?.isAdmin) {
@@ -3640,7 +3327,7 @@ export declare class Validator {
  *
  * ### Internationalization Support
  * ```typescript
- * @ValidationTargetOptions({
+ * @ValidationClassOptions({
  *   errorMessageBuilder: (translatedName, error, { data }) => {
  *     // Use translated property names and localized error formatting
  *     const locale = data.preferredLocale || 'en';
@@ -3670,12 +3357,12 @@ export declare class Validator {
  * @returns Class decorator function that applies the validation configuration
  *
  *
- * @see {@link validateTarget} - Method that uses these options
- * @see {@link getValidateTargetOptions} - Retrieves configured options
+ * @see {@link validateClass} - Method that uses these options
+ * @see {@link getValidatorClassOptions} - Retrieves configured options
  * @decorator
  * @public
  */
-export declare function ValidationTargetOptions(validationOptions: ValidatorValidateTargetOptions<any, any>): ClassDecorator;
+export declare function ValidationClassOptions(validationOptions: ValidatorClassOptions<any, any>): ClassDecorator;
 type ValidatorDefaultArray = Array<unknown>;
 type BuildPropertyDecorator<TRuleParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown> = ValidatorRule<TRuleParams, Context> | ValidatorSanitizedRuleObject<TRuleParams, Context>;
 export {};