reslib 1.1.0 → 2.0.0

package/build/validator/types.d.ts

@@ -1,6 +1,9 @@
 import { I18n } from '../i18n';
 import { InputFormatterResult } from '../inputFormatter/types';
-import { ClassConstructor, Dictionary } from '../types';
+import { ClassConstructor, Dictionary, MakeOptional, MakeRequired } from '../types';
+import { ValidatorBulkError, ValidatorClassError, ValidatorError, ValidatorObjectError } from './errors';
+import { ValidatorClassInput, ValidatorRuleName, ValidatorRuleParamTypes } from './rules.types';
+export * from './rules.types';
 /**
  * ## Validator Sync Result
  *
@@ -12,8 +15,8 @@ import { ClassConstructor, Dictionary } from '../types';
  *
  * This narrow type is intentionally small to make it easy to return a
  * meaningful result from fast, CPU-only rule functions. If a rule needs to
- * perform asynchronous work, it should return a {@link ValidatorAsyncResult}
- * (i.e. a `Promise<ValidatorSyncResult>`).
+ * perform asynchronous work, it should return a {@link ValidatorAsyncRuleResult}
+ * (i.e. a `Promise<ValidatorSyncRuleResult>`).
  *
  * @example
  * ```ts
@@ -26,12 +29,12 @@ import { ClassConstructor, Dictionary } from '../types';
  *
  * @public
  */
-export type ValidatorSyncResult = true | string;
+export type ValidatorSyncRuleResult = true | string;
 /**
  * ## Validator Async Result
  *
  * A convenience alias for the asynchronous validator result. Asynchronous
- * rules return a Promise that resolves to a {@link ValidatorSyncResult}.
+ * rules return a Promise that resolves to a {@link ValidatorSyncRuleResult}.
  *
  * Use this type when declaring asynchronous rule implementations so that
  * type-checking and tooling can correctly surface the expected resolved
@@ -48,7 +51,7 @@ export type ValidatorSyncResult = true | string;
  *
  * @public
  */
-export type ValidatorAsyncResult = Promise<ValidatorSyncResult>;
+export type ValidatorAsyncRuleResult = Promise<ValidatorSyncRuleResult>;
 /**
  * ## Validator Result
  *
@@ -57,8 +60,8 @@ export type ValidatorAsyncResult = Promise<ValidatorSyncResult>;
  * synchronous and asynchronous outcomes so rule implementations can be either
  * sync or async without requiring the caller to have special handling logic.
  *
- * When consuming a `ValidatorResult` you should `await` it, or treat it as a
- * possible `Promise`, which resolves to a `ValidatorSyncResult`.
+ * When consuming a `ValidatorRuleResult` you should `await` it, or treat it as a
+ * possible `Promise`, which resolves to a `ValidatorSyncRuleResult`.
  *
  * @example
  * ```ts
@@ -72,11 +75,11 @@ export type ValidatorAsyncResult = Promise<ValidatorSyncResult>;
  * }
  * ```
  *
- * @see {@link ValidatorSyncResult}
- * @see {@link ValidatorAsyncResult}
+ * @see {@link ValidatorSyncRuleResult}
+ * @see {@link ValidatorAsyncRuleResult}
  * @public
  */
-export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
+export type ValidatorRuleResult = ValidatorSyncRuleResult | ValidatorAsyncRuleResult;
 /**
  * ## Validation Rule Type
  *
@@ -86,7 +89,7 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  *
  * ### Purpose
  * Defines the complete set of valid rule specifications that can be used in validation operations.
- * Supports four different rule formats to accommodate various use cases and developer preferences.
+ * Supports three different rule formats to accommodate various use cases and developer preferences.
  *
  * ### Union Members
  *
@@ -98,17 +101,12 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  *
  * #### 2. Named Rules (`ValidatorRuleName`)
  * Simple string references to built-in validation rules. Most concise format.
+ * Only supports rules that don't require parameters (or have optional parameters).
  * ```typescript
- * "Required" | "Email" | "MinLength" | etc.
+ * "Required" | "Email" | "IsNumber"
  * ```
  *
- * #### 3. Parameterized Rules (Template Literal)
- * Built-in rules with parameters specified in string format. Readable and concise.
- * ```typescript
- * {MinLength:[5]}, {MaxLength:[100]} or {NumberBetween:[0,100]}
- * ```
- *
- * #### 4. Object Rules (`ValidatorRuleObject`)
+ * #### 3. Object Rules (`ValidatorRuleObject`)
  * Structured object format with type-safe parameters. Most type-safe format.
  * ```typescript
  * { MinLength: [5] } | { Email: [] } | { NumberBetween: [0, 100] }
@@ -124,9 +122,8 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * ```typescript
  * const rules: ValidatorRules = [
  *   "Required",                    // Named rule
- *   "MinLength",               // Parameterized rule
- *   { MaxLength: [50] },          // Object rule
- *   ({ value }) => value !== "",  // Function rule
+ *   { MinLength: [5] },            // Object rule
+ *   ({ value }) => value !== "",   // Function rule
  * ];
  * ```
  *
@@ -149,7 +146,7 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * // Multiple rules validation
  * const multiResult = await Validator.validate({
  *   value: "hello",
- *   rules: ["Required", "MinLength", { MaxLength: [10] }],  // ValidatorRule[]
+ *   rules: ["Required", { MinLength: [5] }, { MaxLength: [10] }],  // ValidatorRule[]
  * });
  * ```
  *
@@ -169,7 +166,6 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * ### Performance Considerations
  * - **Function rules**: Fastest (direct execution)
  * - **Named rules**: Fast (lookup table)
- * - **Parameterized rules**: Medium (parsing required)
  * - **Object rules**: Medium (type mapping required)
  *
  * ### Best Practices
@@ -179,12 +175,9 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * // ✅ Use named rules for simple cases
  * const simpleRules = ["Required", "Email"];
  *
- * // ✅ Use parameterized rules for single parameters
+ * // ✅ Use object rules for parameters or type safety
  * const lengthRules = [{ MinLength: [5] }, { MaxLength: [100] }];
  *
- * // ✅ Use object rules for complex parameters or type safety
- * const complexRules = [{ NumberBetween: [0, 100] }];
- *
  * // ✅ Use function rules for custom logic
  * const customRules = [({ value }) => value % 2 === 0];
  * ```
@@ -193,8 +186,8 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * ```typescript
  * const comprehensiveRules: ValidatorRules = [
  *   "Required",           // Built-in
- *   "MinLength",      // Parameterized
- *   { Email: [] },       // Object (type-safe)
+ *   { MinLength: [5] },   // Object (parameterized)
+ *   { Email: [] },        // Object (type-safe)
  *   ({ value, context }) => {  // Custom function
  *     return context?.allowSpecialChars || !/[!@#$%]/.test(value);
  *   },
@@ -206,8 +199,7 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  * ```typescript
  * // These will throw validation errors:
  * const invalid1 = "UnknownRule";        // Rule doesn't exist
- * const invalid2 = "MinLength";     // Invalid parameter type
- * const invalid3 = { UnknownRule: [] };  // Unknown rule name
+ * const invalid2 = { UnknownRule: [] };  // Unknown rule name
  * ```
  *
  * ### Relationship to Validation System
@@ -224,7 +216,7 @@ export type ValidatorResult = ValidatorSyncResult | ValidatorAsyncResult;
  *
  * const userValidationRules: UserRules = [
  *   "Required",
- *   "MinLength",
+ *   { MinLength: [3] },
  *   { MaxLength: [50] },
  *   ({ value }) => !/\s/.test(value),  // No spaces
  * ];
@@ -359,7 +351,7 @@ export type ValidatorOptionalOrEmptyRuleNames = ExtractOptionalOrEmptyKeys<Valid
  * Email: [];                       // No parameters needed
  * PhoneNumber: [countryCode?: string]; // Optional parameter
  *
- * // ❌ Parameterized rules (must be called as "RuleName[param]")
+ * // ❌ Parameterized rules (must be used as { RuleName: [...] })
  * MinLength: [number];             // Required parameter
  * MaxLength: [number];             // Required parameter
  * Length: [number, number?];       // First parameter required
@@ -393,6 +385,90 @@ export type ValidatorTupleAllowsEmpty<T extends Array<unknown>> = T extends [] ?
 type ExtractOptionalOrEmptyKeys<T> = {
     [K in keyof T]: T[K] extends Array<unknown> ? ValidatorTupleAllowsEmpty<T[K]> extends true ? K : never : never;
 }[keyof T];
+/**
+ * @since 1.2.0
+ * Configuration interface for a validation rule object.
+ *
+ * This interface defines the structure for specifying rule parameters and optional customization
+ * like error messages overrides.
+ *
+ * @template TParams - The type of the rule parameters
+ */
+export interface ValidatorRuleConfig<TParams> {
+    /**
+     * The parameters for the validation rule.
+     *
+     * These are the arguments that are passed to the rule function.
+     * The type of these parameters is defined in `ValidatorRuleParamTypes`.
+     */
+    params: TParams;
+    /**
+     * Custom error message that overrides the rule's default message.
+     *
+     * This property allows strict control over the error feedback. It accepts a string
+     * (static or i18n key) or a function for dynamic message generation.
+     *
+     * **Important:** If specified, this message will be used if validation fails, ignoring any
+     * message returned by the rule function itself.
+     *
+     * **Note:** If a function is provided, verify it does not throw. Exceptions are caught and ignored,
+     * causing a fallback to the default message.
+     *
+     * @example
+     * // Static message
+     * message: "This field is required"
+     *
+     * @example
+     * // i18n key
+     * message: "errors.required"
+     *
+     * @example
+     * // Dynamic message function
+     * message: ({ value }) => `Value ${value} is invalid`
+     *
+     * @example
+     * // Dynamic message using i18n from options
+     * message: ({ value, i18n }) => i18n.t('validation.custom_error', { value })
+     *
+     * @see {@link ValidatorRuleConfigMessage}
+     */
+    message?: ValidatorRuleConfigMessage;
+}
+/**
+ * @since 1.2.0
+ * Defines the type for custom error messages in validation rules.
+ *
+ * This type allows for flexibility in defining error messages. It supports:
+ * 1. **Static Strings**: Direct error messages.
+ * 2. **Translation Keys**: Keys for localized messages via standard i18n system.
+ * 3. **Dynamic Functions**: Functions that generate messages based on validation context.
+ *
+ * **Important:** You must return a string. Do not throw exceptions.
+ * If an exception is thrown inside the function, it will be caught and ignored,
+ * falling back to the rule's default error message.
+ *
+ * ### Examples
+ *
+ * **Static String**
+ * ```typescript
+ * message: "This field is strictly required."
+ * ```
+ *
+ * **Translation Key**
+ * ```typescript
+ * message: "validation.errors.required"
+ * ```
+ *
+ * **Dynamic Function**
+ * ```typescript
+ * message: ({ value, fieldName }) => `The value "${value}" is not valid for ${fieldName}.`
+ * ```
+ * **Dynamic Function with i18n**
+ * ```typescript
+ * message: ({ value, i18n }) => i18n.t('the_value_is_required', { value })
+ * ```
+ */
+export type ValidatorRuleConfigMessage = string | ((options: MakeRequired<Omit<ValidatorOptions, 'sanitizedRules' | 'rules' | 'rule'>, 'i18n' | 'ruleName' | 'ruleParams'>) => string);
 /**
  * ## Validation Rule Object Type
  *
@@ -437,6 +513,23 @@ type ExtractOptionalOrEmptyKeys<T> = {
  * };
  * ```
  *
+ * #### Rule Objects with Custom Messages
+ * ```typescript
+ * const customMessageRule: ValidatorRuleObject = {
+ *   Required: {
+ *     params: [],
+ *     message: "This field is absolutely required!"
+ *   }
+ * };
+ *
+ * const detailedRule: ValidatorRuleObject = {
+ *   MinLength: {
+ *     params: [5],
+ *     message: "validation.custom.minLength" // Translation key
+ *   }
+ * };
+ * ```
+ *
  * #### In Validation Rules Array
  * ```typescript
  * const rules: ValidatorRules = [
@@ -466,7 +559,6 @@ type ExtractOptionalOrEmptyKeys<T> = {
  * This type is one of four union members in {@link ValidatorRule}:
  * - `ValidatorRuleFunction` - Custom validation functions
  * - `ValidatorRuleName` - Simple rule names (strings)
- * - `` `${ValidatorRuleName}[${string}]` `` - Parameterized rule strings
  * - `ValidatorRuleObject` - Structured rule objects (this type)
  *
  * ### When to Use
@@ -476,15 +568,7 @@ type ExtractOptionalOrEmptyKeys<T> = {
  * - **Complex Parameters**: Rules with multiple typed parameters
  * - **Refactoring Safety**: Changes to rule signatures are caught by TypeScript
  *
- * ### Comparison with String Rules
- * | Aspect | Object Rules | String Rules |
- * |--------|-------------|--------------|
- * | Type Safety | ✅ Full compile-time checking | ⚠️ Runtime parameter validation |
- * | Autocomplete | ✅ Parameter types shown | ❌ No parameter hints |
- * | Refactoring | ✅ Breaking changes caught | ❌ May break silently |
- * | Readability | ✅ Self-documenting | ⚠️ Requires knowledge of syntax |
- * | Flexibility | ✅ Strongly typed | ✅ Dynamic |
- *
+
  * @template Context - Type of the optional validation context
  *
  * @example
@@ -508,11 +592,12 @@ type ExtractOptionalOrEmptyKeys<T> = {
  * @see {@link ValidatorRule} - Union type that includes this
  * @see {@link ValidatorRuleName} - Valid rule names
  * @see {@link ValidatorRuleParamTypes} - Parameter type definitions
+ * @see {@link ValidatorRuleConfig}
  * @see {@link ValidatorRuleFunction} - Function-based rules
  * @public
  */
 export type ValidatorRuleObject = Partial<{
-    [K in ValidatorRuleName]: ValidatorRuleParamTypes[K];
+    [K in ValidatorRuleName]: ValidatorRuleParamTypes[K] | ValidatorRuleConfig<ValidatorRuleParamTypes[K]>;
 }>;
 /**
  * Represents an array of validation rules to be applied to a value.
@@ -547,7 +632,7 @@ export type ValidatorRuleObject = Partial<{
  * @public
  *
  * @see {@link ValidatorRule} - Individual rule type
- * @see {@link ValidatorValidateOptions} - Options interface that uses this type
+ * @see {@link ValidatorOptions} - Options interface that uses this type
  * @see {@link Validator.validate} - Validation method that accepts these rules
  */
 export type ValidatorRules<Context = unknown> = Array<ValidatorRule<Array<unknown>, Context>>;
@@ -589,7 +674,6 @@ export type ValidatorSanitizedRule<TParams extends ValidatorRuleParams = Validat
  * - **ruleName**: The parsed rule identifier (e.g., "MinLength")
  * - **params**: Array of parameters extracted from the rule (e.g., `[5]`)
  * - **ruleFunction**: The actual validation function to execute
- * - **rawRuleName**: The original unparsed rule string (e.g., {MinLength:[5]})
  *
  * ### Usage in Validation Pipeline
  * ```typescript
@@ -601,7 +685,6 @@ export type ValidatorSanitizedRule<TParams extends ValidatorRuleParams = Validat
  *   ruleName: "MinLength",
  *   params: [8],
  *   ruleFunction: minLengthFunction,
- *   rawRuleName: "MinLength"
  * };
  *
  * // During validation
@@ -667,18 +750,39 @@ export interface ValidatorSanitizedRuleObject<TParams extends ValidatorRuleParam
      */
     ruleFunction: ValidatorRuleFunction<TParams, Context>;
     /**
-     * The original unparsed rule specification
+     * The error message associated with the validation rule.
      *
-     * The raw rule string as it was originally provided, before parsing.
-     * This is useful for error reporting and debugging, as it shows
-     * exactly what the user specified.
+     * Overrides the default error message generated by the `ruleFunction` if validation fails.
+     * Can be a static string, a translation key, or a function that returns a string.
      *
-     * @type {ValidatorRuleName | string}
-     * @example {MinLength:[5]}
-     * @example "Required"
-     * @example "Email"
+     * **Important:** If specified, this message will be used if validation fails, ignoring any
+     * message returned by the rule function itself.
+     *
+     * **Note:** If a function is provided, verify it does not throw. Exceptions are caught and ignored,
+     * causing a fallback to the default message.
+     *
+     * @type {ValidatorRuleConfigMessage}
+     * @since 1.2.0
+     *
+     * @example
+     * // Static string
+     * message: "This field is required."
+     *
+     * @example
+     * // Translation key
+     * message: "auth.email.required"
+     *
+     * @example
+     * // Dynamic function
+     * message: ({ value, ruleParams }) => `Value must be between ${ruleParams[0]} and ${ruleParams[1]}`
+     *
+     * @example
+     * // Dynamic message using i18n from options
+     * message: ({ value, i18n }) => i18n.t('validation.min_length', { value, min: 5 })
+     *
+     * @see {@link ValidatorRuleConfigMessage}
      */
-    rawRuleName: ValidatorRuleName | string;
+    message?: ValidatorRuleConfigMessage;
 }
 /**
  * @typedef ValidatorSanitizedRules
@@ -705,54 +809,55 @@ export interface ValidatorSanitizedRuleObject<TParams extends ValidatorRuleParam
  */
 export type ValidatorSanitizedRules<Context = unknown> = ValidatorSanitizedRule<Array<unknown>, Context>[];
 /**
- * ## Validator Validate Rule Function Type
+ * ## Validator Rule Function
  *
- * Represents a validation rule function that is used within the validation system.
- * This function takes a set of options and performs validation on a given value,
- * returning the result of the validation process.
+ * Represents the fundamental unit of logic in the validation system: a function that validates a value.
  *
- * @template TParams The type of the parameters that the rule function accepts.
+ * This type definition abstracts both **Synchronous** and **Asynchronous** validation logic into a unified
+ * interface, allowing the validator to handle everything from simple checks (regex, length) to complex
+ * operations (database lookups, API calls) seamlessly.
  *
- * ### Structure:
- * - The function accepts a single parameter:
- *   - `options` (ValidatorValidateOptions): An object containing the necessary parameters for validation.
+ * ### Core Responsibilities
+ * 1. **Receive Context**: Accepts a rich options object (`ValidatorOptions`) containing the value, rule parameters, and context.
+ * 2. **Execute Logic**: Performs the actual validation check.
+ * 3. **Report Result**: Returns `true` for success or an error message (string) for failure.
  *
- * ### Parameters:
- * - **options**: An object of type `ValidatorValidateOptions` which includes:
- *   - `rules`: A collection of validation rules to apply. This can be a single rule or an array of rules.
- *   - `rule`: An optional specific validation rule to apply, overriding the rules defined in the `rules` property.
- *   - `value`: The actual value that needs to be validated against the specified rules.
- *   - `ruleParams`: Optional parameters that may be required for specific validation rules.
+ * ### Type Parameters
+ * - **TParams**: Tightly couples the function to a specific set of parameters (e.g., `[min: number]`).
+ * - **Context**: Allows injecting application-specific context (e.g., database connection, user session).
+ *
+ * ### Return Behavior
+ * The return type {@link ValidatorRuleResult} is a union of:
+ * - `boolean`: `true` indicates valid.
+ * - `string`: A non-empty string indicates invalid (the string is the error message/key).
+ * - `Promise<boolean | string>`: For async rules.
  *
- * ### Return Value:
- * - The function returns a {@link ValidatorResult}, which is either:
- *   - a `ValidatorSyncResult` (synchronous rule result) — `true` for success, or a `string` containing the error message on failure
- *   - or a `Promise<ValidatorSyncResult>` (asynchronous rule result)
+ * ### Example Usage
  *
- * ### Example Usage:
+ * #### Synchronous Rule
  * ```typescript
- * function validateEmail({ value }) {
- *     const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
- *     if (!emailPattern.test(value)) {
- *         return "Invalid email format."; // Invalid validation
- *     }
- *     return true; // Valid validation
- * }
+ * const isEven: ValidatorRuleFunction = ({ value }) => {
+ *   if (typeof value !== 'number') return "Value must be a number";
+ *   return value % 2 === 0 || "Value must be even";
+ * };
+ * ```
  *
- * // Example of using the validation function
- * const result = validateEmail({ value: "test@example.com" });
- * if (typeof result === "string") {
- *     console.error(result); // Output: "Invalid email format." if validation fails
- * } else {
- *     console.log("Validation passed."); // Output: "Validation passed." if validation succeeds
- * }
+ * #### Asynchronous Rule
+ * ```typescript
+ * const isUniqueUser: ValidatorRuleFunction = async ({ value, context }) => {
+ *   const user = await context.db.users.findByEmail(value);
+ *   return !user || "Email already exists";
+ * };
  * ```
  *
- * ### Notes:
- * - This type is essential for defining custom validation logic in forms, allowing developers to create reusable and flexible validation rules.
- * - The function can be synchronous or asynchronous, depending on the validation logic implemented.
+ * ### Interaction with Registry
+ * These functions are typically registered with the `Validator` class using names like "MinLength" or "Email",
+ * allowing them to be referenced by string later.
+ *
+ * @see {@link ValidatorOptions} - The input object received by this function.
+ * @see {@link ValidatorRuleResult} - The output produced by this function.
  */
-export type ValidatorRuleFunction<TParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown> = (options: ValidatorValidateOptions<TParams, Context>) => ValidatorResult;
+export type ValidatorRuleFunction<TParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown> = (options: ValidatorOptions<TParams, Context>) => ValidatorRuleResult;
 /**
  * ## Validation Rule Parameters Type
  *
@@ -821,31 +926,31 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  *
  * Configuration interface for validating nested objects or complex data structures
  * within the validation system. This interface is specifically designed for rule functions
- * that need to validate target objects (classes with decorators) rather than simple values.
+ * that need to validate class objects (classes with decorators) rather than simple values.
  *
  * ### Purpose
  * Provides a specialized options interface for validation rule functions that operate on
- * nested or complex data structures. Unlike {@link ValidatorValidateOptions} which handles
+ * nested or complex data structures. Unlike {@link ValidatorOptions} which handles
  * single values, this interface is tailored for scenarios where validation rules need to
  * work with entire class instances or nested object hierarchies.
  *
- * ### Key Differences from ValidatorValidateOptions
- * - **Extends from ValidatorValidateTargetOptions**: Inherits target-specific properties
+ * ### Key Differences from ValidatorOptions
+ * - **Extends from ValidatorClassOptions**: Inherits class-specific properties
  * - **Omits "data" property**: Uses its own `data` property instead
- * - **Optional value property**: Accepts target data instead of single values
+ * - **Optional value property**: Accepts class data instead of single values
  * - **Flexible data property**: Allows any record structure for nested validation
  *
  * ### Inheritance Structure
  * ```
  * ValidatorNestedRuleFunctionOptions
- *   ↳ extends Omit<ValidatorValidateTargetOptions<Target, Context, [target: Target]>, "data">
- *     ↳ extends Omit<ValidatorValidateOptions<TParams, Context>, "data" | "rule" | "value">
+ *   ↳ extends Omit<ValidatorClassOptions<TClass, Context, [classInstance: TClass]>, "data">
+ *     ↳ extends Omit<ValidatorOptions<TParams, Context>, "data" | "rule" | "value">
  *       ↳ extends Omit<Partial<InputFormatterResult>, "value">
- *         ↳ extends BaseData<Context>
+ *         ↳ extends ValidatorBaseOptions<Context>
  * ```
  *
  * ### Generic Parameters
- * - **Target**: The class constructor type being validated (extends `ClassConstructor`)
+ * - **TClass**: The class constructor type being validated (extends `ClassConstructor`)
  * - **Context**: Optional context type for validation (defaults to `unknown`)
  *
  * ### Properties Overview
@@ -854,7 +959,6 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  * - **rules**: Array of validation rules to apply
  * - **ruleParams**: Parameters for the current rule
  * - **ruleName**: Name of the validation rule
- * - **rawRuleName**: Original unparsed rule name
  * - **message**: Custom error message
  * - **fieldName**: Form field identifier
  * - **propertyName**: Object property name
@@ -866,7 +970,7 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  * - **parentData**: Parent context for nested validations
  *
  * #### Own Properties
- * - **value**: Optional target data to validate
+ * - **value**: Optional class data to validate
  * - **data**: Flexible data object for nested validation context
  *
  * ### Usage in Nested Validation
@@ -888,7 +992,7 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  *   // Validate the nested profile
  *   if (value && typeof value === 'object') {
  *     // Perform nested validation logic
- *     const result = await Validator.validateTarget(UserProfile, value);
+ *     const result = await Validator.validateClass(UserProfile, value);
  *     return result.success || "Profile validation failed";
  *   }
  *
@@ -898,8 +1002,8 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  *
  * ### Relationship to Validation System
  * - **Used by**: {@link Validator.validateNestedRule} method
- * - **Complements**: {@link ValidatorValidateTargetOptions} for target validation
- * - **Extends**: {@link ValidatorValidateOptions} with target-specific modifications
+ * - **Complements**: {@link ValidatorClassOptions} for class validation
+ * - **Extends**: {@link ValidatorOptions} with class-specific modifications
  * - **Supports**: Complex nested object validation scenarios
  *
  * ### Common Use Cases
@@ -934,165 +1038,33 @@ export type ValidatorRuleParams<TParams extends Array<unknown> | ReadonlyArray<u
  * ```
  *
  * ### Type Safety Benefits
- * - **Compile-time validation** of target types
+ * - **Compile-time validation** of class types
  * - **Type-safe property access** on nested objects
  * - **Context propagation** through validation hierarchy
  * - **Flexible data structures** for complex validation scenarios
  *
  * ### Performance Considerations
- * - **Target validation overhead**: More expensive than single-value validation
+ * - **Class validation overhead**: More expensive than single-value validation
  * - **Parallel processing**: Multiple nested validations can run concurrently
  * - **Memory usage**: Larger data structures require more memory
  * - **Serialization**: Complex objects may need special handling
  *
- * @template Target - The class constructor type being validated (must extend ClassConstructor)
- * @template Context - Optional context type for validation (defaults to unknown)
- *
- * @public
- *
- * @see {@link ValidatorValidateTargetOptions} - Base target validation options
- * @see {@link ValidatorValidateOptions} - Single-value validation options
- * @see {@link Validator.validateNestedRule} - Method that uses this interface
- * @see {@link ValidatorValidateTargetData} - Target data type
  * @see {@link ClassConstructor} - Class constructor constraint
  */
-export interface ValidatorNestedRuleFunctionOptions<Target extends ClassConstructor = ClassConstructor, Context = unknown> extends Omit<ValidatorValidateTargetOptions<Target, Context, [target: Target]>, 'data'> {
-    value?: ValidatorValidateTargetData<Target>;
+export interface ValidatorNestedRuleFunctionOptions<TClass extends ClassConstructor = ClassConstructor, Context = unknown> extends Omit<ValidatorClassOptions<TClass, Context, [
+    classInstance: TClass,
+    options?: {
+        /**
+         * The custom error message to use when validation fails.
+         * It can be either a translation key or a custom message.
+         */
+        message?: string;
+    }
+]>, 'data'> {
+    value?: ValidatorClassInput<TClass>;
     data?: Dictionary;
 }
-/**
- * @interface ValidatorRuleName
- * Represents the name of a validation rule as defined in the `ValidatorRuleParamTypes`.
- *
- * The `ValidatorRuleName` type is a union of string literal types that correspond to the keys
- * of the `ValidatorRuleParamTypes` interface. This allows for type-safe access to the names of
- * validation rules, ensuring that only valid rule names can be used in contexts where a rule name
- * is required.
- *
- * ### Structure:
- * - The type is derived from the keys of the `ValidatorRuleParamTypes`, meaning it will include
- *   all the rule names defined in that map.
- *
- * ### Example:
- *
- * ```typescript
- * const ruleName: ValidatorRuleName = "required"; // Valid
- * const anotherRuleName: ValidatorRuleName = "minLength"; // Valid
- *
- * // Usage in a function that accepts a rule name
- * function getValidationRule(ruleName: ValidatorRuleName) {
- *     return validationRules[ruleName];
- * }
- *
- * const rule = getValidationRule("maxLength"); // Valid usage
- * // const invalidRule = getValidationRule("unknownRule"); // TypeScript will throw an error
- * ```
- *
- * This type enhances type safety in your code by ensuring that only valid validation rule names
- * can be used, reducing the risk of runtime errors due to typos or invalid rule names.
- */
-export type ValidatorRuleName = keyof ValidatorRuleParamTypes & string;
-/**
- * ## Validation Rules Parameter Map
- *
- * Central type definition mapping validation rule names to their parameter signatures.
- * This interface serves as the authoritative source for all built-in validation rules,
- * defining the exact parameter types each rule accepts.
- *
- * ### Purpose
- * Provides compile-time type safety for validation rule parameters across the entire
- * validation system. Each property represents a built-in validation rule and its
- * expected parameter structure. This is a static interface with no generics.
- *
- * ### Type Structure
- * - **Key**: Rule name (string literal from {@link ValidatorRuleName})
- * - **Value**: Parameter array type (extends {@link ValidatorRuleParams})
- *
- * ### Parameter Type Patterns
- * - **Empty Arrays `[]`**: Rules that take no parameters (e.g., "Required", "Email")
- * - **Complex Parameters**: Rules with mixed required/optional parameters
- *
- * ### Usage in Type System
- * This interface is used throughout the validator to:
- * - Type-check rule parameters at compile time
- * - Generate {@link ValidatorRuleName} union type
- * - Create {@link ValidatorRuleFunctionsMap} registry type
- * - Validate rule definitions in rule implementation files
- *
- * ### Rule Categories
- *
- * #### Presence Validation
- * - **Required**: Ensures value is present and not empty
- * - **Nullable**: Allows null/undefined values (skips validation)
- * - **Optional**: Allows undefined values (skips validation)
- * - **Empty**: Allows empty strings (validation skipped if "")
- *
- * #### Type Validation
- * - **String**: Validates value is a string
- * - **Number**: Validates value is a number
- * - **NonNullString**: Validates value is a non-null string
- *
- * #### String Validation
- * - **MinLength**: Minimum character length requirement
- * - **MaxLength**: Maximum character length limit
- * - **Length**: Exact length or length range (min and optional max)
- * - **FileName**: Valid file name format
- *
- * #### Numeric Validation
- * - **NumberGT**: Value must be greater than specified number
- * - **NumberGTE**: Value must be >= specified number
- * - **NumberLT**: Value must be less than specified number
- * - **NumberLTE**: Value must be <= specified number
- * - **NumberEQ**: Value must equal specified number
- * - **NumberNE**: Value must differ from specified number
- *
- * #### Format Validation
- * - **Email**: Valid email address format
- * - **Url**: Valid URL format
- * - **PhoneNumber**: Valid phone number (with optional country code)
- * - **EmailOrPhoneNumber**: Valid email or phone number
- *
- * ### Parameter Examples
- * ```typescript
- * // Rules with no parameters
- * Required: ValidatorRuleParams<[]>;           // "Required"
- * Email: ValidatorRuleParams<[]>;              // "Email"
- *
- * // Rules with single parameters
- * MinLength: ValidatorRuleParams<[number]>;    // {MinLength:[5]}
- * NumberEQ: ValidatorRuleParams<[number]>;  // "NumberEQ[42]"
- *
- * // Rules with optional parameters
- * PhoneNumber: ValidatorRuleParams<[CountryCode?]>; // "PhoneNumber" or "PhoneNumber[US]"
- *
- * // Rules with multiple parameters
- * Length: ValidatorRuleParams<[number, number?]>; // "Length[5]" or "Length[5,10]"
- * ```
- *
- * ### Extending the Rules Map
- * When adding new validation rules:
- * 1. Add the rule name and parameter type to this interface
- * 2. Implement the rule function in the appropriate rule file
- * 3. Register the rule in the validator's rule registry
- * 4. Update rule name unions and type definitions as needed
- *
- * ### Relationship to Validation System
- * - **Foundation**: Base type for all rule definitions
- * - **Type Safety**: Ensures parameter type checking
- * - **Rule Discovery**: Used to generate valid rule names
- * - **Function Signatures**: Defines parameter types for rule functions
- * - **Runtime Validation**: Parameters validated against these types
- *
- * @public
- * @template Context - Type of the optional validation context
- * @see {@link ValidatorRuleName} - Union type derived from this interface's keys
- * @see {@link ValidatorRuleFunctionsMap} - Registry type using this interface
- * @see {@link ValidatorRuleParams} - Base parameter type for all rules
- * @see {@link Validator} - Main validator class that uses these rules
- */
-export interface ValidatorRuleParamTypes<Context = unknown> {
-}
-export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown> extends Omit<Partial<InputFormatterResult>, 'value'>, BaseData<Context> {
+export interface ValidatorOptions<TParams extends ValidatorRuleParams = ValidatorRuleParams, Context = unknown> extends Omit<Partial<InputFormatterResult>, 'value'>, Omit<ValidatorBaseOptions<Context>, 'status' | 'name'> {
     /**
      * The list of validation rules to apply
      *
@@ -1104,7 +1076,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      *
      * @example
      * ```typescript
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "example@test.com",
      *   rules: [
      *     { ruleName: "Required" },
@@ -1139,7 +1111,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      *
      * @example
      * ```typescript
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "test",
      *   rule: { ruleName: "Required" },
      *   propertyName: "username"
@@ -1162,7 +1134,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      * @example
      * ```typescript
      * // For MinLength rule
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "password123",
      *   rule: { ruleName: "MinLength" },
      *   ruleParams: [8],  // Minimum 8 characters
@@ -1170,7 +1142,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      * };
      *
      * // For NumberBetween rule
-     * const options2: ValidatorValidateOptions = {
+     * const options2: ValidatorOptions = {
      *   value: 50,
      *   rule: { ruleName: "NumberBetween" },
      *   ruleParams: [0, 100],  // Between 0 and 100
@@ -1190,7 +1162,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      *
      * @example
      * ```typescript
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "user@example.com",
      *   ruleName: "Email",
      *   propertyName: "email"
@@ -1200,58 +1172,6 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      * @see {@link ValidatorRuleName}
      */
     ruleName?: ValidatorRuleName;
-    /**
-     * The raw rule name as originally specified (before parsing)
-     *
-     * The unparsed rule name including any parameters in brackets.
-     * For example, {MinLength:[5]} or {NumberGT:[0]} before the name
-     * and parameters are extracted into `ruleName` and `ruleParams`.
-     *
-     * @type {string}
-     * @optional
-     *
-     * @example
-     * ```typescript
-     * const options: ValidatorValidateOptions = {
-     *   value: "test",
-     *   rawRuleName: { MinLength: [5] },      // Raw form
-     *   ruleName: "MinLength",               // Parsed name
-     *   ruleParams: [5],                     // Parsed params
-     *   propertyName: "username"
-     * };
-     * ```
-     */
-    rawRuleName?: ValidatorRuleName | string;
-    /**
-     * Custom error message for validation failure
-     *
-     * Allows specifying a custom error message to display when validation fails.
-     * If provided, this message will be used instead of the default rule-generated message.
-     * Supports i18n translations and dynamic content.
-     *
-     * @type {string}
-     * @optional
-     *
-     * @example
-     * ```typescript
-     * const options: ValidatorValidateOptions = {
-     *   value: "invalid-email",
-     *   rules: ["Email"],
-     *   message: "Please enter a valid email address (e.g., user@example.com)",
-     *   propertyName: "email"
-     * };
-     *
-     * // Custom message for specific context
-     * const options2: ValidatorValidateOptions = {
-     *   value: "short",
-     *   rule: { ruleName: "MinLength" },
-     *   ruleParams: [8],
-     *   message: "Your password must be at least 8 characters for security",
-     *   propertyName: "password"
-     * };
-     * ```
-     */
-    message?: string;
     /**
      * The form field name/identifier
      *
@@ -1264,7 +1184,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      *
      * @example
      * ```typescript
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "invalid@",
      *   rules: ["Email"],
      *   fieldName: "email_input",         // HTML form field ID
@@ -1304,7 +1224,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      *   password: string;
      * }
      *
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "invalid-email",
      *   rules: ["Email"],
      *   propertyName: "email",  // Maps to UserData.email
@@ -1330,7 +1250,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
      * @example
      * ```typescript
      * // Before translation
-     * const options: ValidatorValidateOptions = {
+     * const options: ValidatorOptions = {
      *   value: "invalid",
      *   rules: ["Required"],
      *   propertyName: "user_phone_number"
@@ -1353,7 +1273,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
  * ## OneOf Rule Validation Options
  *
  * Configuration interface for validating a value against an array of alternative validation rules
- * where at least one rule must pass. This interface extends {@link ValidatorValidateOptions}
+ * where at least one rule must pass. This interface extends {@link ValidatorOptions}
  * with specialized properties for OneOf rule validation.
  *
  * ### Purpose
@@ -1377,7 +1297,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
  *
  * #### Basic OneOf Validation Setup
  * ```typescript
- * const options: ValidatorValidateMultiRuleOptions = {
+ * const options: ValidatorMultiRuleOptions = {
  *   value: "user@example.com",
  *   ruleParams: [
  *     ({ value }) => value.includes("@") || "Must contain @",
@@ -1400,7 +1320,7 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
  *   allowedDomains: string[];
  * }
  *
- * const options: ValidatorValidateMultiRuleOptions<ValidationContext> = {
+ * const options: ValidatorMultiRuleOptions<ValidationContext> = {
  *   value: "admin@company.com",
  *   ruleParams: [
  *     // Email validation
@@ -1441,11 +1361,11 @@ export interface ValidatorValidateOptions<TParams extends ValidatorRuleParams =
  *
  * @public
  * @see {@link Validator.validateOneOfRule} - Method that uses this interface
- * @see {@link ValidatorValidateOptions} - Base options interface being extended
+ * @see {@link ValidatorOptions} - Base options interface being extended
  * @see {@link ValidatorRuleFunction} - Type of functions in ruleParams array
- * @see {@link ValidatorValidateResult} - Result type returned by validation
+ * @see {@link ValidatorResult} - Result type returned by validation
  */
-export interface ValidatorValidateMultiRuleOptions<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>> extends ValidatorValidateOptions<RulesFunctions, Context> {
+export interface ValidatorMultiRuleOptions<Context = unknown, RulesFunctions extends ValidatorDefaultMultiRule<Context> = ValidatorDefaultMultiRule<Context>> extends ValidatorOptions<RulesFunctions, Context> {
     startTime?: number;
 }
 /**
@@ -1458,7 +1378,7 @@ export interface ValidatorValidateMultiRuleOptions<Context = unknown, RulesFunct
  * ### Purpose
  * Provides a flexible type for representing collections of validation rules where each rule
  * can have different parameter types. Used as a constraint for {@link ValidatorMultiRuleFunction}
- * and {@link ValidatorValidateMultiRuleOptions} to ensure type safety in multi-rule scenarios.
+ * and {@link ValidatorMultiRuleOptions} to ensure type safety in multi-rule scenarios.
  *
  * ### Type Parameters
  * - **Context**: Optional context type for validation (defaults to `unknown`)
@@ -1479,7 +1399,7 @@ export interface ValidatorValidateMultiRuleOptions<Context = unknown, RulesFunct
  * ```
  *
  * ### Relationship to Validation System
- * - **Used by**: {@link ValidatorValidateMultiRuleOptions} as constraint
+ * - **Used by**: {@link ValidatorMultiRuleOptions} as constraint
  * - **Constrains**: {@link ValidatorMultiRuleFunction} parameter types
  * - **Enables**: Type-safe multi-rule validation operations
  *
@@ -1488,7 +1408,7 @@ export interface ValidatorValidateMultiRuleOptions<Context = unknown, RulesFunct
  *
  * @public
  *
- * @see {@link ValidatorValidateMultiRuleOptions} - Uses this as constraint
+ * @see {@link ValidatorMultiRuleOptions} - Uses this as constraint
  * @see {@link ValidatorMultiRuleFunction} - Function type that accepts this
  * @see {@link ValidatorRule} - Individual rule type
  */
@@ -1511,7 +1431,7 @@ export type ValidatorDefaultMultiRule<Context = unknown, ParamsTypes extends Val
  *
  * ### Function Signature
  * ```typescript
- * (options: ValidatorValidateOptions<RulesFunctions, Context>) => ValidatorResult
+ * (options: ValidatorOptions<RulesFunctions, Context>) => ValidatorRuleResult
  * ```
  *
  * ### Usage in Validation System
@@ -1537,7 +1457,7 @@ export type ValidatorDefaultMultiRule<Context = unknown, ParamsTypes extends Val
  * ### Relationship to Validation System
  * - **Used by**: Multi-rule validation methods in {@link Validator}
  * - **Constrained by**: {@link ValidatorDefaultMultiRule} for parameter types
- * - **Returns**: Standard {@link ValidatorResult} for consistency
+ * - **Returns**: Standard {@link ValidatorRuleResult} for consistency
  * - **Enables**: Complex validation logic with multiple rules
  *
  * @template Context - Type of the optional validation context
@@ -1548,544 +1468,150 @@ export type ValidatorDefaultMultiRule<Context = unknown, ParamsTypes extends Val
  * @see {@link ValidatorDefaultMultiRule} - Constrains the RulesFunctions parameter
  * @see {@link Validator.validateOneOfRule} - Uses this function type
  * @see {@link Validator.validateAllOfRule} - Uses this function type
- * @see {@link ValidatorResult} - Return type
+ * @see {@link ValidatorRuleResult} - Return type
  */
 export type ValidatorMultiRuleFunction<Context = unknown, RulesFunctions extends Array<ValidatorRule<Array<unknown>, Context>> = Array<ValidatorRule<Array<unknown>, Context>>> = ValidatorRuleFunction<RulesFunctions, Context>;
 /**
- * ## Target Validation Data Type
+ * ## Validator Class Options
+ *
+ * Configuration options for performing class-based validation (`Validator.validateClass`).
+ * These options control the behavior of the validation process, including context injection,
+ * error handling, and internationalization.
+ *
+ * ### Inheritance
+ * Extends `ValidatorOptions` but excludes single-value specific properties (`value`, `rule`)
+ * in favor of class-instance specific properties (`data`).
+ */
+export interface ValidatorClassOptions<TClass extends ClassConstructor = ClassConstructor, Context = unknown, ParamsTypes extends ValidatorRuleParams = ValidatorRuleParams> extends Omit<ValidatorOptions<ParamsTypes, Context>, 'data' | 'rule' | 'value'> {
+    data: ValidatorClassInput<TClass>;
+    /**
+     * The parent data/context for nested validations
+     *
+     * When validating nested objects, this property holds the parent
+     */
+    parentData?: Dictionary;
+    startTime?: number;
+    errorMessageBuilder?: (translatedPropertyName: string, error: string, builderOptions: Omit<ValidatorError, 'message'> & {
+        propertyName: keyof InstanceType<TClass> | string;
+        translatedPropertyName: string;
+        cause: ValidatorError;
+        i18n: I18n;
+        separators: {
+            multiple: string;
+            single: string;
+        };
+        data: Partial<Record<keyof InstanceType<TClass>, any>>;
+    }) => string;
+}
+/**
+ * ## Validator Bulk Options
+ *
+ * Configuration for bulk validation operations (validating an array of class instances).
+ * Extends `ValidatorClassOptions` but accepts an array of data objects instead of a single one.
+ * @template TClass - The class constructor type to validate
+ * @template Context - The context type for validation
+ */
+export interface ValidatorBulkOptions<TClass extends ClassConstructor = ClassConstructor, Context = unknown> extends Omit<MakeOptional<ValidatorClassOptions<TClass, Context>, 'i18n'>, 'data' | 'ruleParams'> {
+    data: ValidatorClassInput<TClass>[];
+}
+/**
+ * ## Multi-Rule Names Union
  *
- * A mapped type representing the data structure expected for class-based validation using
- * {@link Validator.validateTarget}. This type creates a partial record mapping class properties
- * to their values, enabling type-safe validation of entire class instances.
+ * A union type defining the names of validation rules that operate on multiple sub-rules.
+ * These rules combine the results of several validation rules using logical operations.
  *
  * ### Purpose
- * Provides compile-time type safety for data passed to {@link Validator.validateTarget} method.
- * Ensures that the data object matches the structure of the target class constructor, allowing
- * validation decorators to be applied to class properties with full type checking.
+ * Defines the specific rule names that support multi-rule validation patterns.
+ * These rules allow combining multiple validation conditions with logical operators
+ * like "one of" or "all of", enabling complex validation scenarios.
  *
- * ### Type Construction
- * ```typescript
- * Partial<Record<keyof InstanceType<Target>, any>>
- * ```
- * - **Target**: Class constructor type (must extend `ClassConstructor`)
- * - **InstanceType<Target>**: Properties of the class instance
- * - **Partial**: All properties are optional (validation fills in defaults)
- * - **Record<..., any>**: Values can be any type (validation will check)
+ * ### Supported Multi-Rules
+ * - **'OneOf'**: Passes if at least one of the sub-rules passes (logical OR)
+ * - **'AllOf'**: Passes only if all sub-rules pass (logical AND)
  *
- * ### Usage in Target Validation
+ * ### Type Structure
+ * Simple string literal union with two possible values:
  * ```typescript
- * class UserForm {
- *   @IsRequired()
- *   @IsEmail()
- *   email: string;
- *
- *   @IsRequired()
- *   @MinLength(3)
- *   name: string;
+ * 'OneOf' | 'AllOf'
+ * ```
  *
- *   @IsOptional()
- *   age?: number;
- * }
+ * ### Usage in Validation
+ * Multi-rule names are used in {@link ValidatorMultiRuleFunction} to specify
+ * which logical operation to apply to a collection of validation rules.
  *
- * // Type-safe data object
- * const data: ValidatorValidateTargetData<UserForm> = {
- *   email: "user@example.com",  // ✓ Matches UserForm.email
- *   name: "John",               // ✓ Matches UserForm.name
- *   age: 25,                    // ✓ Matches UserForm.age
+ * ```typescript
+ * // Example: Email must be valid OR be empty (optional email field)
+ * const rule: ValidatorMultiRuleFunction = (rules, context) => {
+ *   return rules.OneOf([
+ *     rules.Email([], context),
+ *     rules.IsEmpty([], context)
+ *   ]);
  * };
- *
- * const result = await Validator.validateTarget(UserForm, data);
  * ```
  *
- * ### Key Features
- * - **Partial Mapping**: Not all class properties need to be provided
- * - **Type Safety**: Property names and types are checked at compile time
- * - **Decorator Integration**: Works with validation decorators on class properties
- * - **Flexible Values**: Accepts any value type (validation rules determine validity)
- *
- * ### Comparison with Single-Value Validation
- * | Aspect | Target Data | Single Value |
- * |--------|-------------|--------------|
- * | Structure | Object with multiple properties | Single value |
- * | Validation | Multiple fields simultaneously | One value at a time |
- * | Type Safety | Class property mapping | Any value type |
- * | Use Case | Form validation | Field validation |
+ * ### Relationship to Validation System
+ * - **Used by**: {@link ValidatorMultiRuleFunction} as operation selector
+ * - **Implemented in**: Rule registry as special multi-rule handlers
+ * - **Combines with**: Regular validation rules via logical operations
+ * - **Returns**: Single validation result from multiple rule evaluations
  *
- * ### Runtime Behavior
- * - **Missing Properties**: Validation decorators determine if properties are required
- * - **Extra Properties**: Ignored (only decorated properties are validated)
- * - **Type Coercion**: Values are validated according to decorator rules, not TypeScript types
+ * ### Key Characteristics
+ * - **Logical Operations**: Supports OR ('OneOf') and AND ('AllOf') combinations
+ * - **Rule Composition**: Enables building complex validation logic from simple rules
+ * - **Type Safety**: Compile-time guarantees for valid multi-rule names
+ * - **Extensible**: New logical operations can be added by extending this union
  *
- * ### Relationship to Validation System
- * - **Used by**: {@link Validator.validateTarget} as input data type
- * - **Mapped from**: Class constructor type via `InstanceType<Target>`
- * - **Validated by**: Decorator-based rules on class properties
- * - **Returns**: {@link ValidatorValidateTargetResult} with validated instance
+ * ### Comparison with Single Rules
+ * | Aspect | Single Rule | Multi-Rule |
+ * |--------|-------------|------------|
+ * | Operation | One condition | Multiple conditions |
+ * | Logic | Direct validation | Logical combination |
+ * | Use Case | Basic validation | Complex conditional validation |
+ * | Example | "IsEmail" | "OneOf(IsEmail, IsEmpty())" |
  *
- * @template Target - The class constructor type being validated
+ * ### Runtime Behavior
+ * - **OneOf**: Returns success if any sub-rule passes, failure if all fail
+ * - **AllOf**: Returns success only if all sub-rules pass, failure if any fails
+ * - **Short-circuiting**: May stop evaluation early based on logical operation
+ * - **Error Aggregation**: Collects errors from all evaluated rules
  *
  * @public
  *
- * @see {@link Validator.validateTarget} - Method that accepts this data type
- * @see {@link ValidatorValidateTargetOptions} - Options type that includes this
- * @see {@link ValidatorValidateTargetResult} - Result type returned after validation
- * @see {@link ClassConstructor} - Base constructor type constraint
+ * @see {@link ValidatorMultiRuleFunction} - Function type that uses these names
+ * @see {@link ValidatorDefaultMultiRule} - Default multi-rule configuration
+ * @see {@link ValidatorRuleName} - General rule names (includes these)
  */
-export type ValidatorValidateTargetData<Target extends ClassConstructor = ClassConstructor> = Partial<Record<keyof InstanceType<Target>, any>>;
+export type ValidatorMultiRuleNames = 'OneOf' | 'AllOf';
 /**
- * ## Target Validation Options
- *
- * Configuration interface for validating entire class instances with decorated properties.
- * This interface extends {@link ValidatorValidateOptions} with target-specific properties
- * for complex object validation scenarios.
+ * ## Validation Result Types (Either Pattern)
  *
- * ### Purpose
- * Provides a specialized options interface for validating class instances where multiple
- * properties have validation decorators. Unlike single-value validation, this interface
- * handles validation of entire objects with potentially many fields and nested structures.
+ * Uses the Either<L, R> pattern where Left represents failure and Right represents success.
+ * This provides strong type safety and prevents accessing wrong properties based on the result state.
+ */
+/**
+ * ## Single Value Validation Success Result
  *
- * ### Key Differences from ValidatorValidateOptions
- * - **data property**: Required and typed as target data (not optional generic data)
- * - **Omits "rule" and "value"**: Uses target-specific data structure instead
- * - **parentData**: Supports nested validation context
- * - **errorMessageBuilder**: Customizable error message formatting for target validation
- * - **startTime**: Performance tracking for multi-field validation
+ * Represents a successful validation result for a single value.
+ * This type is used as the success branch of the {@link ValidatorResult} discriminated union.
  *
- * ### Inheritance Structure
- * ```
- * ValidatorValidateTargetOptions
- *   ↳ extends Omit<ValidatorValidateOptions<ParamsTypes, Context>, "data" | "rule" | "value">
- *     ↳ extends Omit<Partial<InputFormatterResult>, "value">
- *       ↳ extends BaseData<Context> (but overrides data property)
+ * ### Type Guard
+ * Can be narrowed using {@link Validator.isSuccess}:
+ * ```typescript
+ * if (Validator.isSuccess(result)) {
+ *   // TypeScript knows: result satisfies ValidatorSuccess
+ *   // Can safely access result.value, result.validatedAt, result.duration
+ * }
  * ```
  *
- * ### Generic Parameters
- * - **Target**: The class constructor type being validated (extends `ClassConstructor`)
- * - **Context**: Optional context type for validation (defaults to `unknown`)
- * - **ParamsTypes**: Parameter types for validation rules (defaults to `ValidatorRuleParams`)
- *
- * ### Properties Overview
- *
- * #### Inherited Properties (from ValidatorValidateOptions)
- * - **rules**: Array of validation rules to apply to the target
- * - **ruleParams**: Parameters for the current rule
- * - **ruleName**: Name of the validation rule
- * - **rawRuleName**: Original unparsed rule name
- * - **message**: Custom error message
- * - **fieldName**: Form field identifier
- * - **propertyName**: Object property name
- * - **translatedPropertyName**: Localized property name
- * - **i18n**: Internationalization instance
- * - **sanitizedRules**: Preprocessed rules
- *
- * #### Target-Specific Properties
- * - **data**: Required target data to validate (typed as `ValidatorValidateTargetData<Target>`)
- * - **parentData**: Parent context for nested validations
- * - **startTime**: Performance tracking timestamp
- * - **errorMessageBuilder**: Custom error message builder function
- *
- * ### Usage in Target Validation
- * ```typescript
- * class UserProfile {
- *   @IsRequired()
- *   @IsEmail()
- *   email: string;
- *
- *   @IsRequired()
- *   @MinLength(2)
- *   name: string;
- *
- *   @ValidateNested
- *   address: Address;
- * }
- *
- * // Basic target validation
- * const options: ValidatorValidateTargetOptions<UserProfile> = {
- *   data: {
- *     email: "user@example.com",
- *     name: "John",
- *     address: { street: "123 Main St", city: "Anytown" }
- *   },
- *   propertyName: "userProfile",
- *   context: validationContext,
- *   i18n: defaultI18n,
- * };
- *
- * const result = await Validator.validateTarget(UserProfile, options.data);
- * ```
- *
- * ### Error Message Builder
- * The `errorMessageBuilder` allows customization of error message formatting:
- * ```typescript
- * const customErrorBuilder = (
- *   translatedPropertyName: string,
- *   error: string,
- *   options: ValidatorValidationError & {
- *     propertyName: string;
- *     translatedPropertyName: string;
- *     i18n: I18n;
- *     separators: { multiple: string; single: string };
- *     data: Partial<Record<keyof Target, any>>;
- *   }
- * ) => {
- *   return `[${translatedPropertyName}]: ${error}`;
- * };
- *
- * const options: ValidatorValidateTargetOptions<UserProfile> = {
- *   data: userData,
- *   errorMessageBuilder: customErrorBuilder,
- * };
- * ```
- *
- * ### Nested Validation Context
- * The `parentData` property enables context sharing in nested validations:
- * ```typescript
- * // Parent validation
- * const parentOptions: ValidatorValidateTargetOptions<Company> = {
- *   data: {
- *     name: "ACME Corp",
- *     employees: [employeeData1, employeeData2]
- *   },
- *   parentData: undefined, // Root level
- * };
- *
- * // Nested validation (for each employee)
- * const nestedOptions: ValidatorValidateTargetOptions<Employee> = {
- *   data: employeeData,
- *   parentData: { companyName: "ACME Corp" }, // Context from parent
- *   propertyName: "employee",
- * };
- * ```
- *
- * ### Performance Tracking
- * The `startTime` property enables duration measurement:
- * ```typescript
- * const startTime = Date.now();
- * const options: ValidatorValidateTargetOptions<UserForm> = {
- *   data: formData,
- *   startTime, // Track when validation began
- * };
- *
- * const result = await Validator.validateTarget(UserForm, formData, options);
- * if (result.success) {
- *   console.log(`Validation took ${result.duration}ms`);
- * }
- * ```
- *
- * ### Type Safety Benefits
- * - **Compile-time validation** of target class types
- * - **Property type checking** for data objects
- * - **Context propagation** through validation hierarchy
- * - **Error message customization** with proper typing
- *
- * ### Common Use Cases
- *
- * #### 1. Form Validation
- * ```typescript
- * const formOptions: ValidatorValidateTargetOptions<RegistrationForm> = {
- *   data: {
- *     email: submittedEmail,
- *     password: submittedPassword,
- *     confirmPassword: submittedConfirm,
- *   },
- *   fieldName: "registration_form",
- *   context: { userType: "new" },
- * };
- * ```
- *
- * #### 2. API Request Validation
- * ```typescript
- * const apiOptions: ValidatorValidateTargetOptions<CreateUserRequest> = {
- *   data: requestBody,
- *   propertyName: "request",
- *   context: { requestId: req.id, userAgent: req.headers['user-agent'] },
- * };
- * ```
- *
- * #### 3. Nested Object Validation
- * ```typescript
- * const nestedOptions: ValidatorValidateTargetOptions<OrderItem> = {
- *   data: itemData,
- *   parentData: { orderId: "12345", customerId: "67890" },
- *   propertyName: "item",
- *   errorMessageBuilder: customFormatter,
- * };
- * ```
- *
- * ### Relationship to Validation System
- * - **Used by**: {@link Validator.validateTarget} method
- * - **Extends**: {@link ValidatorValidateOptions} with target-specific modifications
- * - **Supports**: Multi-field validation with error aggregation
- * - **Integrates with**: Decorator-based validation system
- *
- * @template Target - The class constructor type being validated (must extend ClassConstructor)
- * @template Context - Optional context type for validation (defaults to unknown)
- * @template ParamsTypes - Parameter types for validation rules (defaults to ValidatorRuleParams)
- *
- * @public
- *
- * @see {@link ValidatorValidateOptions} - Base options interface being extended
- * @see {@link ValidatorValidateTargetData} - Target data type
- * @see {@link Validator.validateTarget} - Method that uses this interface
- * @see {@link ClassConstructor} - Class constructor constraint
- * @see {@link ValidatorValidationError} - Error type for errorMessageBuilder
- */
-export interface ValidatorValidateTargetOptions<Target extends ClassConstructor = ClassConstructor, Context = unknown, ParamsTypes extends ValidatorRuleParams = ValidatorRuleParams> extends Omit<ValidatorValidateOptions<ParamsTypes, Context>, 'data' | 'rule' | 'value'> {
-    data: ValidatorValidateTargetData<Target>;
-    /**
-     * The parent data/context for nested validations
-     *
-     * When validating nested objects, this property holds the parent
-     */
-    parentData?: Dictionary;
-    startTime?: number;
-    errorMessageBuilder?: (translatedPropertyName: string, error: string, builderOptions: ValidatorValidationError & {
-        propertyName: keyof InstanceType<Target> | string;
-        translatedPropertyName: string;
-        i18n: I18n;
-        separators: {
-            multiple: string;
-            single: string;
-        };
-        data: Partial<Record<keyof InstanceType<Target>, any>>;
-    }) => string;
-}
-/**
- * ## Multi-Rule Names Union
- *
- * A union type defining the names of validation rules that operate on multiple sub-rules.
- * These rules combine the results of several validation rules using logical operations.
- *
- * ### Purpose
- * Defines the specific rule names that support multi-rule validation patterns.
- * These rules allow combining multiple validation conditions with logical operators
- * like "one of" or "all of", enabling complex validation scenarios.
- *
- * ### Supported Multi-Rules
- * - **'OneOf'**: Passes if at least one of the sub-rules passes (logical OR)
- * - **'AllOf'**: Passes only if all sub-rules pass (logical AND)
- *
- * ### Type Structure
- * Simple string literal union with two possible values:
- * ```typescript
- * 'OneOf' | 'AllOf'
- * ```
- *
- * ### Usage in Validation
- * Multi-rule names are used in {@link ValidatorMultiRuleFunction} to specify
- * which logical operation to apply to a collection of validation rules.
- *
- * ```typescript
- * // Example: Email must be valid OR be empty (optional email field)
- * const rule: ValidatorMultiRuleFunction = (rules, context) => {
- *   return rules.OneOf([
- *     rules.Email([], context),
- *     rules.IsEmpty([], context)
- *   ]);
- * };
- * ```
- *
- * ### Relationship to Validation System
- * - **Used by**: {@link ValidatorMultiRuleFunction} as operation selector
- * - **Implemented in**: Rule registry as special multi-rule handlers
- * - **Combines with**: Regular validation rules via logical operations
- * - **Returns**: Single validation result from multiple rule evaluations
- *
- * ### Key Characteristics
- * - **Logical Operations**: Supports OR ('OneOf') and AND ('AllOf') combinations
- * - **Rule Composition**: Enables building complex validation logic from simple rules
- * - **Type Safety**: Compile-time guarantees for valid multi-rule names
- * - **Extensible**: New logical operations can be added by extending this union
- *
- * ### Comparison with Single Rules
- * | Aspect | Single Rule | Multi-Rule |
- * |--------|-------------|------------|
- * | Operation | One condition | Multiple conditions |
- * | Logic | Direct validation | Logical combination |
- * | Use Case | Basic validation | Complex conditional validation |
- * | Example | "IsEmail" | "OneOf(IsEmail, IsEmpty())" |
- *
- * ### Runtime Behavior
- * - **OneOf**: Returns success if any sub-rule passes, failure if all fail
- * - **AllOf**: Returns success only if all sub-rules pass, failure if any fails
- * - **Short-circuiting**: May stop evaluation early based on logical operation
- * - **Error Aggregation**: Collects errors from all evaluated rules
- *
- * @public
- *
- * @see {@link ValidatorMultiRuleFunction} - Function type that uses these names
- * @see {@link ValidatorDefaultMultiRule} - Default multi-rule configuration
- * @see {@link ValidatorRuleName} - General rule names (includes these)
- */
-export type ValidatorMultiRuleNames = 'OneOf' | 'AllOf';
-/**
- * ## Validation Result Types (Either Pattern)
- *
- * Uses the Either<L, R> pattern where Left represents failure and Right represents success.
- * This provides strong type safety and prevents accessing wrong properties based on the result state.
- */
-/**
- * ## Validation Error Details
- *
- * Comprehensive error information structure for validation failures.
- * This interface defines the complete error object that is returned when validation rules fail,
- * providing detailed context about what went wrong and where.
- *
- * ### Purpose
- * Serves as the standardized error format across the entire validation system.
- * Contains all necessary information for error reporting, debugging, and user feedback.
- * Used by both single-value and target validation failure results.
- *
- * ### Key Properties
- * - **status**: Always "error" for type discrimination
- * - **name**: Error class name ("ValidatorValidationError")
- * - **message**: Human-readable error message (translated if available)
- * - **ruleName**: The specific validation rule that failed
- * - **value**: The actual value that failed validation
- * - **propertyName**: Object property name (for target validation)
- * - **fieldName**: Form field identifier
- *
- * ### Usage in Validation Results
- * This interface is used in failure results:
- * - {@link ValidatorValidateFailure.error} - Single value validation failures
- * - {@link ValidatorValidateTargetFailure.errors} - Array of errors in target validation
- *
- * ### Error Message Structure
- * Error messages follow a consistent format:
- * ```
- * "[PropertyName]: Error message from rule"
- * ```
- * For example: `"[Email]: Must be valid email format"`
- *
- * ### Internationalization Support
- * - **translatedPropertyName**: Localized property name for user-facing messages
- * - **message**: Can be translated based on i18n configuration
- * - **timestamp**: When the error occurred (for logging/debugging)
- *
- * ### Metadata and Extensibility
- * - **code**: Programmatic error code for conditional handling
- * - **severity**: Error level ("error", "warning", "info")
- * - **metadata**: Additional error context as key-value pairs
- *
- * ### Example Error Object
- * ```typescript
- * const error: ValidatorValidationError = {
- *   status: "error",
- *   name: "ValidatorValidationError",
- *   message: "[Email]: Must be valid email format",
- *   ruleName: "Email",
- *   ruleParams: [],
- *   rawRuleName: "Email",
- *   propertyName: "email",
- *   fieldName: "email_input",
- *   translatedPropertyName: "Email Address",
- *   value: "invalid-email",
- *   code: "INVALID_EMAIL",
- *   severity: "error",
- *   timestamp: new Date(),
- *   metadata: {
- *     suggestion: "Please use format: user@example.com",
- *     domain: "example.com"
- *   }
- * };
- * ```
- *
- * ### Relationship to Validation System
- * - **Created by**: Validation rule functions when they return failure strings
- * - **Processed by**: {@link Validator.validate} and {@link Validator.validateTarget}
- * - **Used in**: Error aggregation and reporting throughout the system
- * - **Compatible with**: Standard error handling patterns and logging systems
- *
- * ### Best Practices
- *
- * #### Error Message Guidelines
- * ```typescript
- * // ✅ Good: Specific, actionable messages
- * message: "[Password]: Must contain at least one uppercase letter"
- *
- * // ❌ Avoid: Generic or unhelpful messages
- * message: "Invalid input"
- * ```
- *
- * #### Using Error Codes
- * ```typescript
- * // Enable programmatic error handling
- * if (error.code === "EMAIL_INVALID_FORMAT") {
- *   highlightEmailField();
- *   showEmailFormatHint();
- * }
- * ```
- *
- * #### Metadata for Rich Errors
- * ```typescript
- * // Provide additional context
- * error.metadata = {
- *   minLength: 8,
- *   actualLength: 5,
- *   missingChars: ["uppercase", "number"]
- * };
- * ```
- *
- * @public
- *
- * @see {@link ValidatorValidateFailure} - Single validation failure result
- * @see {@link ValidatorValidateTargetFailure} - Target validation failure result
- * @see {@link Validator.validate} - Method that creates these errors
- * @see {@link Validator.validateTarget} - Method that creates these errors
- */
-export interface ValidatorValidationError {
-    /** Always 'error' for failures */
-    status: 'error';
-    name: 'ValidatorValidationError';
-    /** The property name that failed validation (required) */
-    fieldName?: string;
-    /** Alias for fieldName (required) */
-    propertyName?: string;
-    /** The validation error message (required) */
-    message: string;
-    /** Localized field name for user-facing messages */
-    translatedPropertyName?: string;
-    /** The specific rule that failed */
-    ruleName?: ValidatorRuleName;
-    /** Parameters passed to the failing rule */
-    ruleParams: any[];
-    /** The value that failed validation */
-    value: any;
-    /** Raw rule name with parameters (e.g., "minLength[5]") */
-    rawRuleName?: ValidatorRuleName | string;
-    /** Error code for programmatic handling */
-    code?: string;
-    /** Error severity level */
-    severity?: 'error' | 'warning' | 'info';
-    /** When the validation failed */
-    timestamp?: Date;
-    /** Additional error metadata */
-    metadata?: Dictionary;
-}
-/**
- * ## Single Value Validation Success Result
- *
- * Represents a successful validation result for a single value.
- * This type is used as the success branch of the {@link ValidatorValidateResult} discriminated union.
- *
- * ### Type Guard
- * Can be narrowed using {@link Validator.isSuccess}:
- * ```typescript
- * if (Validator.isSuccess(result)) {
- *   // TypeScript knows: result satisfies ValidatorValidateSuccess
- *   // Can safely access result.value, result.validatedAt, result.duration
- * }
- * ```
- *
- * ### Properties
- * - **success**: Literal `true` for type discrimination
- * - **value**: The original value that passed validation
- * - **validatedAt**: ISO timestamp indicating when validation completed
- * - **duration**: Duration in milliseconds from validation start to completion
- * - **error**: Explicitly `undefined` for success (aids type narrowing)
- * - **failedAt**: Explicitly `undefined` for success (aids type narrowing)
- * - **data**: Optional context data (inherited from BaseData)
- * - **context**: Optional validation context (inherited from BaseData)
+ * ### Properties
+ * - **success**: Literal `true` for type discrimination
+ * - **value**: The original value that passed validation
+ * - **validatedAt**: ISO timestamp indicating when validation completed
+ * - **duration**: Duration in milliseconds from validation start to completion
+ * - **error**: Explicitly `undefined` for success (aids type narrowing)
+ * - **failedAt**: Explicitly `undefined` for success (aids type narrowing)
+ * - **data**: Optional context data (inherited from ValidatorBaseOptions)
+ * - **context**: Optional validation context (inherited from ValidatorBaseOptions)
  *
  * ### Example
  * ```typescript
@@ -2095,7 +1621,7 @@ export interface ValidatorValidationError {
  * });
  *
  * if (result.success) {
- *   // result is ValidatorValidateSuccess
+ *   // result is ValidatorSuccess
  *   console.log("Validated:", result.value);
  *   console.log("Took:", result.duration, "ms");
  *   console.log("Completed at:", result.validatedAt.toISOString());
@@ -2106,12 +1632,12 @@ export interface ValidatorValidationError {
  *
  * @public
  *
- * @see {@link ValidatorValidateResult}
- * @see {@link ValidatorValidateFailure}
+ * @see {@link ValidatorResult}
+ * @see {@link ValidatorError}
  * @see {@link Validator.validate}
  * @see {@link Validator.isSuccess}
  */
-export interface ValidatorValidateSuccess<Context = unknown> extends BaseData<Context> {
+export interface ValidatorSuccess<Context = unknown> extends ValidatorBaseOptions<Context> {
     /** Discriminant for type narrowing - always `true` for success */
     success: true;
     /**
@@ -2128,234 +1654,7 @@ export interface ValidatorValidateSuccess<Context = unknown> extends BaseData<Co
     error?: undefined;
     /** Always undefined for success results (type narrowing aid) */
     failedAt?: undefined;
-}
-/**
- * ## Base Data Structure
- *
- * Shared data structure for both validation success and failure results.
- * Contains the core properties that exist in all validation outcomes.
- *
- * ### Purpose
- * Provides a common interface for passing data through the validation pipeline
- * and in the result objects. Used by both {@link ValidatorValidateSuccess}
- * and {@link ValidatorValidateFailure}.
- *
- * ### Properties
- * - **value**: The actual value being validated (required)
- * - **data**: Optional contextual data available to validation rules
- * - **context**: Optional typed context object for advanced validations
- *
- * ### Usage in Validation Results
- * ```typescript
- * // In ValidatorValidateSuccess
- * const successResult: ValidatorValidateSuccess = {
- *   success: true,
- *   value: "user@example.com",  // Original validated value
- *   data: { userId: 123 },      // Additional context
- *   context: { ... },           // Typed context object
- *   validatedAt: new Date(),
- *   duration: 5,
- * };
- *
- * // In ValidatorValidateFailure
- * const failureResult: ValidatorValidateFailure = {
- *   success: false,
- *   value: "invalid-email",     // Value that failed
- *   data: { userId: 123 },      // Available during failure too
- *   context: { ... },           // Context from validation request
- *   error: { ... },
- *   failedAt: new Date(),
- *   duration: 2,
- * };
- * ```
- *
- * @template Context - Type parameter for optional typed context object
- *
- * @public
- *
- * @see {@link ValidatorValidateOptions} - Options passed to validation
- * @see {@link ValidatorValidateSuccess} - Success result type
- * @see {@link ValidatorValidateFailure} - Failure result type
- */
-interface BaseData<Context = unknown> {
-    /**
-     * The value to use for performing the validation.
-     * This is the actual data that will be validated against the specified rules.
-     *
-     * @type {any}
-     *
-     * @example
-     * ```typescript
-     * const result = await Validator.validate({
-     *   value: "user@example.com",  // This is the value being validated
-     *   rules: ["Required", "Email"],
-     * });
-     * ```
-     *
-     * @remarks
-     * - This is the core data being validated
-     * - Type can be any JavaScript value: string, number, object, array, etc.
-     * - Available in both success and failure results
-     */
-    value: any;
-    /**
-     * Optional data object providing contextual information for validation rules.
-     *
-     * This property is used to provide additional context for the validation rule.
-     * It can be used to pass any additional data that might be needed for validation,
-     * such as form data, related field values, or other contextual information.
-     *
-     * @type {Dictionary | undefined}
-     *
-     * @example
-     * ```typescript
-     * const result = await Validator.validate({
-     *   value: "test@example.com",
-     *   rules: ["Required", "Email"],
-     *   data: {
-     *     userId: 123,
-     *     formId: "user_form",
-     *   },
-     * });
-     * ```
-     *
-     * @remarks
-     * - Optional property (not required)
-     * - Passed to validation rule functions via options.data
-     * - Useful for multi-field validation scenarios
-     * - Commonly used for form data context in validateTarget
-     */
-    data?: Dictionary;
-    /**
-     * Optional typed context object for validation.
-     *
-     * Provides a typed context that can be passed to validation rules for
-     * advanced validation scenarios requiring external data or permissions.
-     *
-     * @template Context - Type of the context object
-     *
-     * @example
-     * ```typescript
-     * interface UserContext {
-     *   userId: number;
-     *   permissions: string[];
-     *   isAdmin: boolean;
-     * }
-     *
-     * const result = await Validator.validate<UserContext>({
-     *   value: "admin_action",
-     *   rules: ["Required"],
-     *   context: {
-     *     userId: 123,
-     *     permissions: ["read", "write", "admin"],
-     *     isAdmin: true,
-     *   },
-     * });
-     * ```
-     *
-     * @remarks
-     * - Optional property (not required)
-     * - Type is defined by the Context generic parameter
-     * - Passed to all validation rule functions
-     * - Enables context-aware validation rules
-     * - Commonly used for permission-based or user-specific validations
-     */
-    context?: Context;
-}
-/**
- * ## Single Value Validation Failure Result
- *
- * Represents a failed validation result for a single value.
- * This type is used as the failure branch of the {@link ValidatorValidateResult} discriminated union.
- *
- * ### Type Guard
- * Can be narrowed using {@link Validator.isFailure}:
- * ```typescript
- * if (Validator.isFailure(result)) {
- *   // TypeScript knows: result satisfies ValidatorValidateFailure
- *   // Can safely access result.error, result.failedAt, result.duration
- * }
- * ```
- *
- * ### Properties
- * - **success**: Literal `false` for type discrimination
- * - **error**: Validation error details (name, message, rule info)
- * - **failedAt**: ISO timestamp indicating when validation failed
- * - **duration**: Duration in milliseconds until failure
- * - **validatedAt**: Explicitly `undefined` for failure (aids type narrowing)
- * - **value**: The original value that failed validation
- * - **data**: Optional context data (inherited from BaseData)
- * - **context**: Optional validation context (inherited from BaseData)
- *
- * ### Error Object Structure
- * The `error` property contains:
- * ```typescript
- * {
- *   name: "ValidatorValidationError",
- *   message: "Error message (translated if available)",
- *   ruleName: "Email",              // Name of failing rule
- *   ruleParams: [],                 // Parameters passed to rule
- *   rawRuleName: "Email",           // Original rule specification
- *   fieldName: "email_field",       // Optional field identifier
- *   propertyName: "email",          // Optional property name
- *   translatedPropertyName?: "Email Address", // Translated name
- *   value: "invalid@",              // Value that failed
- * }
- * ```
- *
- * ### Example
- * ```typescript
- * const result = await Validator.validate({
- *   value: "not-an-email",
- *   rules: ["Required", "Email"],
- * });
- *
- * if (!result.success) {
- *   // result is ValidatorValidateFailure
- *   console.error("Validation failed:");
- *   console.error("  Value:", result.value);
- *   console.error("  Error:", result.error.message);
- *   console.error("  Rule:", result.error.ruleName);
- *   console.error("  Failed at:", result.failedAt.toISOString());
- *   console.error("  Duration:", result.duration, "ms");
- * }
- * ```
- *
- * @template Context - Type of the optional validation context
- *
- * @public
- *
- * @see {@link ValidatorValidateResult}
- * @see {@link ValidatorValidateSuccess}
- * @see {@link ValidatorValidationError}
- * @see {@link Validator.validate}
- * @see {@link Validator.isFailure}
- */
-export interface ValidatorValidateFailure<Context = unknown> extends BaseData<Context> {
-    /** Discriminant for type narrowing - always `false` for failure */
-    success: false;
-    /**
-     * The validation error details
-     *
-     * Contains complete information about what validation rule failed
-     * and why, including the rule name, parameters, and error message.
-     *
-     * @type {ValidatorValidationError}
-     * @see {@link ValidatorValidationError}
-     */
-    error: ValidatorValidationError;
-    /**
-     * ISO timestamp indicating when validation failed
-     * @example "2024-11-08T10:30:45.118Z"
-     */
-    failedAt?: Date;
-    /**
-     * Duration of validation before failure in milliseconds
-     * @example 2 (milliseconds - failed quickly on first rule)
-     */
-    duration?: number;
-    /** Always undefined for failure results (type narrowing aid) */
-    validatedAt?: undefined;
+    message?: string | undefined;
 }
 /**
  * ## Validation Result Type (Discriminated Union)
@@ -2370,12 +1669,12 @@ export interface ValidatorValidateFailure<Context = unknown> extends BaseData<Co
  * const result = await Validator.validate({ value: "...", rules: [...] });
  *
  * if (result.success) {
- *   // TypeScript knows: ValidatorValidateSuccess
+ *   // TypeScript knows: ValidatorSuccess
  *   console.log(result.value);      // ✓ Available
  *   console.log(result.validatedAt); // ✓ Available
  *   console.log(result.error);      // ✗ Type error (undefined for success)
  * } else {
- *   // TypeScript knows: ValidatorValidateFailure
+ *   // TypeScript knows: ValidatorError
  *   console.log(result.value);      // ✓ Available
  *   console.log(result.error);      // ✓ Available
  *   console.log(result.validatedAt); // ✗ Type error (undefined for failure)
@@ -2387,11 +1686,11 @@ export interface ValidatorValidateFailure<Context = unknown> extends BaseData<Co
  * const result = await Validator.validate({ value: "...", rules: [...] });
  *
  * if (Validator.isSuccess(result)) {
- *   // result is ValidatorValidateSuccess<Context>
+ *   // result is ValidatorSuccess<Context>
  *   console.log(result.value);
  *   console.log(result.validatedAt);
- * } else if (Validator.isFailure(result)) {
- *   // result is ValidatorValidateFailure<Context>
+ * } else if (Validator.isValidatorError(result)) {
+ *   // result is ValidatorError
  *   console.log(result.error.message);
  *   console.log(result.error.ruleName);
  * }
@@ -2412,8 +1711,8 @@ export interface ValidatorValidateFailure<Context = unknown> extends BaseData<Co
  * ```
  *
  * ### Union Members
- * - {@link ValidatorValidateSuccess} - When validation passes (success: true)
- * - {@link ValidatorValidateFailure} - When validation fails (success: false)
+ * - {@link ValidatorSuccess} - When validation passes (success: true)
+ * - {@link ValidatorError} - When validation fails (success: false)
  *
  * @template Context - Type of the optional validation context
  *
@@ -2423,199 +1722,42 @@ export interface ValidatorValidateFailure<Context = unknown> extends BaseData<Co
  *   userId: number;
  * }
  *
- * const result: ValidatorValidateResult<MyContext> = await Validator.validate({
+ * const result: ValidatorResult<MyContext> = await Validator.validate({
  *   value: "test@example.com",
  *   rules: ["Required", "Email"],
  *   context: { userId: 123 },
  * });
  * ```
- *
- * @public
- *
- * @see {@link ValidatorValidateSuccess} - Success variant
- * @see {@link ValidatorValidateFailure} - Failure variant
- * @see {@link Validator.validate} - Main validation method
- * @see {@link Validator.isSuccess} - Type guard for success
- * @see {@link Validator.isFailure} - Type guard for failure
- */
-export type ValidatorValidateResult<Context = unknown> = ValidatorValidateSuccess<Context> | ValidatorValidateFailure<Context>;
-/**
- * ## Validate Target Result Types
- *
- * Types for class-based validation using decorators.
- * Supports accumulation of multiple field errors across all decorated properties.
- *
- * ### Key Differences from Single-Value Validation
- * - **Multiple Errors**: Collects errors from all fields that fail validation
- * - **Parallel Validation**: All fields are validated concurrently
- * - **Error Aggregation**: Returns array of errors with field-level details
- * - **Class-Based**: Works with decorated class properties rather than single values
- * - **FieldMeta Mapping**: Maps validated data back to class structure with proper typing
- */
-/**
- * ## Class Validation Failure Result
- *
- * Represents a failed multi-field validation result when using {@link Validator.validateTarget}.
- * Unlike single-value validation, this accumulates errors from all fields that fail.
- *
- * ### Type Guard
- * Can be narrowed by checking the `success` property:
- * ```typescript
- * const result = await Validator.validateTarget(UserForm, data);
- *
- * if (!result.success) {
- *   // result is ValidatorValidateTargetFailure
- *   console.log(result.errors);      // Array of field errors
- *   console.log(result.failureCount); // Number of failed fields
- *   console.log(result.message);     // Summary message
- * }
- * ```
- *
- * ### Properties
- * - **success**: Literal `false` for type discrimination
- * - **errors**: Array of ValidatorValidationError, one per failed field
- * - **failureCount**: Number of fields that failed validation
- * - **message**: Summary message (e.g., "Validation failed for 3 fields")
- * - **status**: Always "error" for consistency
- * - **failedAt**: ISO timestamp of when validation failed
- * - **duration**: Milliseconds elapsed during validation
- * - **data**: Always `undefined` for target failures
- * - **value**: Always `undefined` for target (use `errors` instead)
- * - **context**: Optional validation context provided
- *
- * ### Error Array Structure
- * Each error in the `errors` array contains:
- * ```typescript
- * {
- *   name: "ValidatorValidationError",
- *   status: "error",
- *   fieldName: "email_field",       // Form field identifier
- *   propertyName: "email",          // Class property name
- *   message: "[Email]: Must be valid email",  // Formatted error message
- *   ruleName: "Email",              // Name of failing rule
- *   ruleParams: [],                 // Rule parameters
- *   value: "invalid@",              // Value that failed
- * }
- * ```
- *
- * ### Example
- * ```typescript
- * class UserForm {
- *   @IsRequired()
- *   @IsEmail()
- *   email: string;
- *
- *   @IsRequired()
- *   @MinLength(3)
- *   name: string;
- * }
- *
- * const result = await Validator.validateTarget(UserForm, {
- *   email: "invalid-email",
- *   name: "ab",  // Too short
- * });
- *
- * if (!result.success) {
- *   // result.failureCount === 2
- *   // result.errors.length === 2
- *   result.errors.forEach(error => {
- *     console.error(`${error.propertyName}: ${error.message}`);
- *   });
- * }
- * ```
- * @template Context - Type of the optional validation context
- *
- * @public
- *
- * @see {@link ValidatorValidateTargetResult}
- * @see {@link ValidatorValidationError}
- * @see {@link Validator.validateTarget}
- */
-export interface ValidatorValidateTargetFailure<Context = unknown> extends Omit<BaseData<Context>, 'value' | 'data'> {
-    /** Discriminant for type narrowing - always `false` for failures */
-    success: false;
-    /**
-     * Summary message describing the failure
-     *
-     * Typically formatted as "Validation failed for N fields" where N is the number of failures.
-     * Can be customized via i18n translations.
-     *
-     * @type {string}
-     * @example "Validation failed for 3 fields"
-     */
-    message: string;
-    /**
-     * Array of validation errors for each field that failed
-     *
-     * Contains one error object per field that failed validation.
-     * Each error includes the field name, error message, rule name, and value.
-     *
-     * @type {ValidatorValidationError[]}
-     * @see {@link ValidatorValidationError}
-     */
-    errors: ValidatorValidationError[];
-    /**
-     * Number of fields that failed validation
-     *
-     * Equal to errors.length. Provided for convenience.
-     *
-     * @type {number}
-     * @example 3
-     */
-    failureCount: number;
-    /**
-     * Status indicator for this result
-     *
-     * Always "error" for failures. Provided for consistency with HTTP and API conventions.
-     *
-     * @type {"error"}
-     */
-    status: 'error';
-    /**
-     * ISO timestamp of when validation failed
-     *
-     * Indicates the exact time validation completed with failures.
-     *
-     * @type {Date | undefined}
-     * @example new Date("2024-11-08T10:30:45.523Z")
-     */
-    failedAt?: Date;
-    /**
-     * Duration of validation in milliseconds
-     *
-     * Measures time from validation start until failures were detected.
-     * Note: All fields are validated in parallel, so this is not the sum of individual field times.
-     *
-     * @type {number | undefined}
-     * @example 45 (milliseconds)
-     */
-    duration?: number;
-    /** Validation context (if provided) */
-    context?: Context;
-    /** Always `undefined` for target failures (type narrowing aid) */
-    validatedAt?: undefined;
-    data: Dictionary;
-}
+ *
+ * @public
+ *
+ * @see {@link ValidatorSuccess} - Success variant
+ * @see {@link ValidatorError} - Failure variant
+ * @see {@link Validator.validate} - Main validation method
+ * @see {@link Validator.isSuccess} - Type guard for success
+ * @see {@link Validator.isFailure} - Type guard for failure
+ */
+export type ValidatorResult<Context = unknown> = ValidatorSuccess<Context> | ValidatorError;
 /**
  * ## Class Validation Success Result
  *
- * Represents a successful multi-field validation result when using {@link Validator.validateTarget}.
+ * Represents a successful multi-field validation result when using {@link Validator.validateClass}.
  * All decorated fields passed their respective validation rules.
  *
  * ### Type Guard
  * Can be narrowed by checking the `success` property:
  * ```typescript
- * const result = await Validator.validateTarget(UserForm, data);
+ * const result = await Validator.validateClass(UserForm, data);
  *
  * if (result.success) {
- *   // result is ValidatorValidateTargetSuccess
+ *   // result is ValidatorClassSuccess
  *   console.log(result.data);        // Validated instance of T
  *   console.log(result.validatedAt); // Timestamp of validation
  * }
  * ```
  *
  * ### Properties vs Single-Value Success
- * Unlike {@link ValidatorValidateSuccess}, target success uses:
+ * Unlike {@link ValidatorSuccess}, class validation success uses:
  * - **data**: The validated class instance (not `value`)
  * - **value**: Always `undefined` (type narrowing aid)
  * - **errors**: Always `undefined` (type narrowing aid)
@@ -2635,7 +1777,7 @@ export interface ValidatorValidateTargetFailure<Context = unknown> extends Omit<
  *   name: string;
  * }
  *
- * const result = await Validator.validateTarget(UserForm, {
+ * const result = await Validator.validateClass(UserForm, {
  *   email: "user@example.com",
  *   name: "John",
  * });
@@ -2652,7 +1794,7 @@ export interface ValidatorValidateTargetFailure<Context = unknown> extends Omit<
  * ```
  *
  * ### Comparison with Single-Value Success
- * | Aspect | Single-Value | Target |
+ * | Aspect | Single-Value | TClass |
  * |--------|-------------|--------|
  * | Property | `value` | `data` |
  * | Validates | One value | Multiple fields |
@@ -2666,7 +1808,7 @@ export interface ValidatorValidateTargetFailure<Context = unknown> extends Omit<
  * form.email = "user@example.com";
  * form.name = "John";
  *
- * const result = await Validator.validateTarget(UserForm, form);
+ * const result = await Validator.validateClass(UserForm, form);
  *
  * if (result.success) {
  *   // Safe to use result.data
@@ -2679,23 +1821,13 @@ export interface ValidatorValidateTargetFailure<Context = unknown> extends Omit<
  *
  * @public
  *
- * @see {@link ValidatorValidateTargetResult}
- * @see {@link ValidatorValidateSuccess} - Single-value equivalent
- * @see {@link Validator.validateTarget}
+ * @see {@link ValidatorClassResult}
+ * @see {@link ValidatorSuccess} - Single-value equivalent
  */
-export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<BaseData<Context>, 'data'> {
+export interface ValidatorClassSuccess<TClass extends ClassConstructor = ClassConstructor, Context = unknown> extends Omit<ValidatorBaseOptions<Context>, 'data' | 'value'> {
     /** Discriminant for type narrowing - always `true` for success */
     success: true;
     message?: undefined;
-    /**
-     * Status indicator for this result
-     *
-     * Always "success" for successful validations. Provided for consistency with HTTP
-     * and API conventions.
-     *
-     * @type {"success"}
-     */
-    status: 'success';
     /**
      * ISO timestamp of when validation succeeded
      *
@@ -2715,26 +1847,41 @@ export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<
      * @example 23 (milliseconds)
      */
     duration?: number;
-    data: Dictionary;
+    data: ValidatorClassInput<TClass>;
+}
+/**
+ * ## Validator Object Success
+ *
+ * Represents a successful validation result for a plain object.
+ * This is the success variant of the discriminated union {@link ValidatorObjectResult}.
+ *
+ * It contains the original data object and metadata about the validation.
+ *
+ * @template TObject - The type of the validated object
+ * @template Context - Optional validation context type
+ * @public
+ */
+export interface ValidatorObjectSuccess<TObject extends object, Context = unknown> extends Omit<ValidatorClassSuccess<ClassConstructor, Context>, 'data'> {
+    data: TObject;
 }
 /**
  * ## Class Validation Result Type (Discriminated Union)
  *
- * Discriminated union type representing the result of a {@link Validator.validateTarget} operation.
- * Can be either {@link ValidatorValidateTargetSuccess} or {@link ValidatorValidateTargetFailure}.
+ * Discriminated union type representing the result of a {@link Validator.validateClass} operation.
+ * Can be either {@link ValidatorClassSuccess} or {@link ValidatorClassError}.
  *
  * ### Type Narrowing Strategies
  *
  * **Strategy 1: Check `success` property**
  * ```typescript
- * const result = await Validator.validateTarget(UserForm, data);
+ * const result = await Validator.validateClass(UserForm, data);
  *
  * if (result.success) {
- *   // result is ValidatorValidateTargetSuccess<T>
+ *   // result is ValidatorClassSuccess<T>
  *   console.log(result.data);        // Class instance with all fields valid
  *   console.log(result.validatedAt); // Validation timestamp
  * } else {
- *   // result is ValidatorValidateTargetFailure
+ *   // result is ValidatorClassError
  *   console.log(result.errors);      // Array of field-level errors
  *   console.log(result.failureCount); // Number of failed fields
  * }
@@ -2744,11 +1891,11 @@ export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<
  * ```typescript
  * switch (result.status) {
  *   case "success":
- *     // result is ValidatorValidateTargetSuccess
+ *     // result is ValidatorClassSuccess
  *     await saveToDatabase(result.data);
  *     break;
  *   case "error":
- *     // result is ValidatorValidateTargetFailure
+ *     // result is ValidatorClassError
  *     logErrors(result.errors);
  *     break;
  * }
@@ -2757,15 +1904,15 @@ export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<
  * **Strategy 3: Use type guard helper**
  * ```typescript
  * if (Validator.isSuccess(result)) {
- *   // result is ValidatorValidateTargetSuccess
+ *   // result is ValidatorClassSuccess
  *   return result.data;
  * }
- * // result is ValidatorValidateTargetFailure
+ * // result is ValidatorClassError
  * throw new Error(result.message);
  * ```
  *
  * ### Comparison with Single-Value Result
- * | Aspect | Single-Value | Target |
+ * | Aspect | Single-Value | TClass |
  * |--------|-------------|--------|
  * | Success Property | `value` | `data` |
  * | On Failure | Single error | Array of errors |
@@ -2788,7 +1935,7 @@ export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<
  *   confirmPassword: string;
  * }
  *
- * const result = await Validator.validateTarget(RegistrationForm, {
+ * const result = await Validator.validateClass(RegistrationForm, {
  *   email: "user@example.com",
  *   password: "SecurePass123",
  *   confirmPassword: "SecurePass123",
@@ -2806,21 +1953,243 @@ export interface ValidatorValidateTargetSuccess<Context = unknown> extends Omit<
  * ```
  *
  * ### Union Members
- * - {@link ValidatorValidateTargetSuccess} - When all fields pass (success: true)
- * - {@link ValidatorValidateTargetFailure} - When one or more fields fail (success: false)
+ * - {@link ValidatorClassSuccess} - When all fields pass (success: true)
+ * - {@link ValidatorClassError} - When one or more fields fail (success: false)
  *
  * @template Context - Type of the optional validation context
  *
  * @public
  *
- * @see {@link ValidatorValidateTargetSuccess} - Success variant
- * @see {@link ValidatorValidateTargetFailure} - Failure variant
- * @see {@link Validator.validateTarget} - Main target validation method
+ * @see {@link ValidatorClassSuccess} - Success variant
+ * @see {@link ValidatorClassError} - Failure variant
+ * @see {@link Validator.validateClass} - Main class validation method
+ * @see {@link Validator.isSuccess} - Type guard for success
+ * @see {@link Validator.isFailure} - Type guard for failure
+ * @see {@link ValidatorResult} - Single-value equivalent
+ */
+export type ValidatorClassResult<TClass extends ClassConstructor = ClassConstructor, Context = unknown> = ValidatorClassSuccess<TClass, Context> | ValidatorClassError<TClass>;
+/**
+ * ## Validator Bulk Success
+ *
+ * Represents a successful bulk validation result when validating an array of class instances.
+ * This interface extends the single-item success structure but operates on arrays of data.
+ *
+ * ### Purpose
+ * Provides a structured success response for batch validation operations, indicating that
+ * all items in the input array passed validation successfully. This is the success variant
+ * of the discriminated union {@link ValidatorBulkResult}.
+ *
+ * ### Key Characteristics
+ * - **success**: Always `true` for this type
+ * - **data**: Contains the validated array of items (all items passed validation)
+ * - **Inherits**: All properties from {@link ValidatorClassSuccess} except `data`
+ *
+ * ### Usage Scenarios
+ * - Batch user registration validation
+ * - Bulk data import validation
+ * - CSV/Excel file validation
+ * - API batch endpoint validation
+ * - Mass data migration validation
+ *
+ * @template TClass - The class constructor type being validated
+ * @template Context - Optional context type for validation
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @IsRequired()
+ *   @IsEmail()
+ *   email: string;
+ *
+ *   @IsRequired()
+ *   @MinLength(3)
+ *   name: string;
+ * }
+ *
+ * const users = [
+ *   { email: 'user1@example.com', name: 'Alice' },
+ *   { email: 'user2@example.com', name: 'Bob' }
+ * ];
+ *
+ * const result = await Validator.validateBulk(User, { data: users });
+ *
+ * if (result.success) {
+ *   // Type: ValidatorBulkSuccess<typeof User>
+ *   console.log(`All ${result.data.length} users are valid`);
+ *   result.data.forEach(user => {
+ *     // Process validated user data
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With context
+ * interface ValidationContext {
+ *   organizationId: string;
+ * }
+ *
+ * const result = await Validator.validateBulk<typeof User, ValidationContext>(
+ *   User,
+ *   {
+ *     data: users,
+ *     context: { organizationId: '123' }
+ *   }
+ * );
+ *
+ * if (result.success) {
+ *   // All items validated successfully
+ *   console.log('Validation duration:', result.duration);
+ * }
+ * ```
+ *
+ * @see {@link ValidatorBulkResult} - The discriminated union type
+ * @see {@link ValidatorBulkError} - The failure variant
+ * @see {@link ValidatorClassSuccess} - Single-item success type
+ * @see {@link Validator.validateBulk} - Method that returns this type
+ * @public
+ */
+export interface ValidatorBulkSuccess<TClass extends ClassConstructor = ClassConstructor, Context = unknown> extends Omit<ValidatorClassSuccess<TClass, Context>, 'data'> {
+    /**
+     * The validated array of data items.
+     * All items in this array have passed validation successfully.
+     */
+    data: ValidatorClassInput<TClass>[];
+}
+/**
+ * ## Validator Bulk Result
+ *
+ * Discriminated union type representing the outcome of a bulk validation operation.
+ * This type can be either a success (all items valid) or an error (one or more items failed).
+ *
+ * ### Purpose
+ * Provides type-safe handling of bulk validation results through TypeScript's discriminated
+ * union pattern. The `success` property acts as the discriminant, allowing TypeScript to
+ * narrow the type automatically in conditional branches.
+ *
+ * ### Type Structure
+ * - **Success case**: {@link ValidatorBulkSuccess} - All items passed validation
+ * - **Failure case**: {@link ValidatorBulkError} - One or more items failed validation
+ *
+ * ### Discriminant Property
+ * The `success` boolean property serves as the type discriminant:
+ * - `success: true` → Type narrows to `ValidatorBulkSuccess`
+ * - `success: false` → Type narrows to `ValidatorBulkError`
+ *
+ * ### Usage Patterns
+ *
+ * **Type Narrowing with if/else:**
+ * ```typescript
+ * const result = await Validator.validateBulk(User, { data: users });
+ *
+ * if (result.success) {
+ *   // TypeScript knows: result is ValidatorBulkSuccess
+ *   result.data.forEach(user => processUser(user));
+ * } else {
+ *   // TypeScript knows: result is ValidatorBulkError
+ *   console.error(`${result.failureCount} items failed`);
+ *   result.failures.forEach(failure => {
+ *     console.log(`Item ${failure.index}: ${failure.message}`);
+ *   });
+ * }
+ * ```
+ *
+ * **Type Guards:**
+ * ```typescript
+ * if (Validator.isSuccess(result)) {
+ *   // result is ValidatorBulkSuccess
+ *   return result.data;
+ * }
+ *
+ * if (Validator.isFailure(result)) {
+ *   // result is ValidatorBulkError
+ *   throw new Error(result.message);
+ * }
+ * ```
+ *
+ * **Exhaustive Handling:**
+ * ```typescript
+ * const result = await Validator.validateBulk(User, { data: users });
+ *
+ * switch (result.success) {
+ *   case true:
+ *     // Handle success
+ *     return { validated: result.data };
+ *   case false:
+ *     // Handle failure
+ *     return { errors: result.failures };
+ * }
+ * ```
+ *
+ * @template TClass - The class constructor type being validated
+ * @template Context - Optional context type for validation
+ *
+ * @example
+ * ```typescript
+ * class Product {
+ *   @IsRequired()
+ *   name: string;
+ *
+ *   @IsNumber()
+ *   @NumberGTE(0)
+ *   price: number;
+ * }
+ *
+ * async function importProducts(
+ *   products: Array<{ name: string; price: number }>
+ * ): Promise<ValidatorBulkResult<typeof Product>> {
+ *   return Validator.validateBulk(Product, { data: products });
+ * }
+ *
+ * // Usage
+ * const result = await importProducts([
+ *   { name: 'Widget', price: 10 },
+ *   { name: 'Gadget', price: -5 }, // Invalid: negative price
+ * ]);
+ *
+ * if (result.success) {
+ *   console.log('All products valid');
+ * } else {
+ *   console.log(`${result.failureCount} products failed validation`);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // API endpoint example
+ * async function bulkCreateUsers(
+ *   req: Request,
+ *   res: Response
+ * ): Promise<void> {
+ *   const result = await Validator.validateBulk(User, {
+ *     data: req.body.users
+ *   });
+ *
+ *   if (result.success) {
+ *     const created = await db.users.insertMany(result.data);
+ *     res.json({ success: true, count: created.length });
+ *   } else {
+ *     res.status(400).json({
+ *       success: false,
+ *       message: result.message,
+ *       failures: result.failures.map(f => ({
+ *         index: f.index,
+ *         errors: f.errors
+ *       }))
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link ValidatorBulkSuccess} - Success variant
+ * @see {@link ValidatorBulkError} - Failure variant
+ * @see {@link ValidatorClassResult} - Single-item equivalent
+ * @see {@link Validator.validateBulk} - Method that returns this type
  * @see {@link Validator.isSuccess} - Type guard for success
  * @see {@link Validator.isFailure} - Type guard for failure
- * @see {@link ValidatorValidateResult} - Single-value equivalent
+ * @public
  */
-export type ValidatorValidateTargetResult<Context = unknown> = ValidatorValidateTargetSuccess<Context> | ValidatorValidateTargetFailure<Context>;
+export type ValidatorBulkResult<TClass extends ClassConstructor = ClassConstructor, Context = unknown> = ValidatorBulkSuccess<TClass, Context> | ValidatorBulkError<TClass>;
 /**
  * ## Validator Rule Functions Map
  *
@@ -2847,7 +2216,7 @@ export type ValidatorValidateTargetResult<Context = unknown> = ValidatorValidate
  * ### Usage in Validator Class
  * This type is primarily used internally by the {@link Validator} class:
  * - {@link Validator.getRules} returns an instance of this mapped type
- * - {@link Validator.validateTarget} uses it to retrieve rule functions by name
+ * - {@link Validator.validateClass} uses it to retrieve rule functions by name
  * - Rule execution methods access functions through this type-safe lookup table
  *
  * ### Example Structure
@@ -2893,9 +2262,186 @@ export type ValidatorValidateTargetResult<Context = unknown> = ValidatorValidate
  * @see {@link ValidatorRuleParamTypes} - Rule parameter definitions
  * @see {@link ValidatorRuleFunction} - Validation function signature
  * @see {@link Validator.getRules} - Method that returns this map
- * @see {@link Validator.validateTarget} - Method that uses this map
+ * @see {@link Validator.validateClass} - Method that uses this map
  */
 export type ValidatorRuleFunctionsMap<Context = unknown> = {
     [K in ValidatorRuleName]: ValidatorRuleFunction<ValidatorRuleParamTypes<Context>[K], Context>;
 };
-export {};
+/**
+ * ## Validator Base Options
+ *
+ * The foundational type that defines the core data properties involved in any validation operation.
+ * It serves as the base for both:
+ * 1. **Validation Options**: The input configurations passed to validation methods (e.g., {@link ValidatorOptions}).
+ * 2. **Validation Results**: The successful output of validation containing the validated data (e.g., {@link ValidatorSuccess}).
+ *
+ * ### Purpose
+ * This interface identifies the three key pieces of data in the validation lifecycle:
+ * - **value**: The primary data being validated.
+ * - **data**: Auxiliary data (e.g., the full form object) for cross-field validation.
+ * - **context**: Application-specific context (e.g., database connections, user session) injected into rules.
+ *
+ * ### Usage
+ * You typically don't use this type directly. Instead, you use one of its specialized extensions:
+ * - Use {@link ValidatorOptions} for calling `Validator.validate()`
+ * - Use {@link ValidatorClassResult} or {@link ValidatorSuccess} when handling return values
+ *
+ * @template Context - Type of the optional application context
+ * @public
+ */
+export interface ValidatorBaseOptions<Context = unknown> {
+    /**
+     * The value to use for performing the validation.
+     * This is the actual data that will be validated against the specified rules.
+     *
+     * @type {any}
+     *
+     * @example
+     * ```typescript
+     * const result = await Validator.validate({
+     *   value: "user@example.com",  // This is the value being validated
+     *   rules: ["Required", "Email"],
+     * });
+     * ```
+     *
+     * @remarks
+     * - This is the core data being validated
+     * - Type can be any JavaScript value: string, number, object, array, etc.
+     * - Available in both success and failure results
+     */
+    value: any;
+    /**
+     * Optional data object providing contextual information for validation rules.
+     *
+     * This property is used to provide additional context for the validation rule.
+     * It can be used to pass any additional data that might be needed for validation,
+     * such as form data, related field values, or other contextual information.
+     *
+     * @type {Dictionary | undefined}
+     *
+     * @example
+     * ```typescript
+     * const result = await Validator.validate({
+     *   value: "test@example.com",
+     *   rules: ["Required", "Email"],
+     *   data: {
+     *     userId: 123,
+     *     formId: "user_form",
+     *   },
+     * });
+     * ```
+     *
+     * @remarks
+     * - Optional property (not required)
+     * - Passed to validation rule functions via options.data
+     * - Useful for multi-field validation scenarios
+     * - Commonly used for form data context in validateClass
+     */
+    data?: Dictionary;
+    /**
+     * Optional typed context object for validation.
+     *
+     * Provides a typed context that can be passed to validation rules for
+     * advanced validation scenarios requiring external data or permissions.
+     *
+     * @template Context - Type of the context object
+     *
+     * @example
+     * ```typescript
+     * interface UserContext {
+     *   userId: number;
+     *   permissions: string[];
+     *   isAdmin: boolean;
+     * }
+     *
+     * const result = await Validator.validate<UserContext>({
+     *   value: "admin_action",
+     *   rules: ["Required"],
+     *   context: {
+     *     userId: 123,
+     *     permissions: ["read", "write", "admin"],
+     *     isAdmin: true,
+     *   },
+     * });
+     * ```
+     *
+     * @remarks
+     * - Optional property (not required)
+     * - Type is defined by the Context generic parameter
+     * - Passed to all validation rule functions
+     * - Enables context-aware validation rules
+     * - Commonly used for permission-based or user-specific validations
+     */
+    context?: Context;
+    /**
+     * Status indicator for this result
+     *
+     * Always "success" for successful validations. Provided for consistency with HTTP
+     * and API conventions.
+     *
+     * @type {"success"}
+     */
+    status: 'success';
+    name: 'ValidatorSuccessResult';
+}
+/**
+ * ## Validator Object Schema Interface
+ *
+ * Defines the structure for object-based validation schemas created with `Validator.object()`.
+ * This enables a functional, Zod-like validation pattern where rules are defined
+ * outside of classes.
+ *
+ * @template T - The type of data to validate
+ * @template Context - Optional validation context type
+ *
+ * @public
+ */
+export interface ValidatorObjectSchema<T extends object, Context = unknown> {
+    /** The internal schema target object containing metadata */
+    readonly schema: object;
+    /**
+     * Validates a data object against this schema.
+     *
+     * @template Context - The custom validation context
+     * @param data - The data to validate
+     * @param options - Optional validation configuration
+     * @returns Promise resolving to a structured validation result
+     */
+    validate(data: T, options?: Omit<ValidatorObjectOptions<T, Context>, 'data' | 'rules'>): Promise<ValidatorObjectResult<T, Context>>;
+}
+/**
+ * ## Validator Object Rules
+ *
+ * A type representing the validation rules for a plain object.
+ * Maps property names to their respective validation rules.
+ *
+ * @template T - The type of the object being validated
+ * @public
+ */
+export type ValidatorObjectRules<T extends object> = {
+    [K in keyof T | string]: ValidatorRules;
+};
+/**
+ * ## Validator Object Options
+ *
+ * Configuration options for object-based validation (`Validator.validateObject`).
+ * Extends class validation options but focuses on plain object data.
+ *
+ * @template T - The type of data to validate
+ * @template Context - Optional validation context type
+ * @public
+ */
+export interface ValidatorObjectOptions<T extends object, Context = unknown> extends Omit<MakeOptional<ValidatorClassOptions<ClassConstructor, Context>, 'i18n'>, 'data' | 'rules' | 'ruleParams'> {
+    data: T;
+}
+/**
+ * ## Validator Object Result
+ *
+ * Discriminated union type representing the result of a {@link Validator.validateObject} operation.
+ * Can be either {@link ValidatorObjectSuccess} or {@link ValidatorObjectError}.
+ *
+ * @template T - The type of data being validated
+ * @template Context - Optional validation context type
+ * @public
+ */
+export type ValidatorObjectResult<T extends object, Context = unknown> = ValidatorObjectSuccess<T, Context> | ValidatorObjectError<T>;