reslib 1.0.0

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

@@ -0,0 +1,848 @@
+/**
+ * ## IsArray Decorator
+ *
+ * Property decorator that validates a property value is an array.
+ * This is a fundamental array validation decorator that ensures the value
+ * is actually an array before applying other array-specific validations.
+ *
+ * ### Usage
+ * ```typescript
+ * class ProductList {
+ *   @IsArray()
+ *   products: Product[];
+ * }
+ * ```
+ *
+ * ### Validation Behavior
+ * - **Passes**: When value is an array (including empty arrays)
+ * - **Fails**: When value is not an array (null, undefined, object, string, number, etc.)
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must be an array"`
+ * - I18n key: `"validator.array"`
+ *
+ * ### Related Decorators
+ * - Often used as prerequisite for: `@ArrayMinLength`, `@ArrayMaxLength`, `@ArrayLength`, `@ArrayContains`, `@ArrayUnique`, `@ArrayAllStrings`, `@ArrayAllNumbers`
+ *
+ * @returns A property decorator function
+ * @public
+ */
+export declare const IsArray: () => PropertyDecorator;
+/**
+ * ## ArrayMinLength Decorator
+ *
+ * Property decorator that validates an array has at least the specified minimum number of elements.
+ * Ensures arrays meet minimum size requirements for business logic.
+ *
+ * ### Usage
+ * ```typescript
+ * class ShoppingCart {
+ *   @IsArray()
+ *   @ArrayMinLength(1)
+ *   items: CartItem[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - `minLength: number` - The minimum number of elements required
+ *
+ * ### Validation Behavior
+ * - **Passes**: When array length >= minimum length
+ * - **Fails**: When array length < minimum length
+ * - **Edge cases**: Empty arrays fail if minLength > 0
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must contain at least {minLength} items"`
+ * - I18n key: `"validator.arrayMinLength"`
+ *
+ * ### Performance
+ * - **O(1) operation**: Only checks array length property
+ * - Fast validation suitable for large arrays
+ *
+ * @param minLength - Minimum number of elements required
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayMinLength: (minLength: number) => PropertyDecorator;
+/**
+ * ## ArrayMaxLength Decorator
+ *
+ * Property decorator that validates an array does not exceed the specified maximum number of elements.
+ * Prevents arrays from growing beyond acceptable limits to avoid memory issues or performance problems.
+ *
+ * ### Usage
+ * ```typescript
+ * class FileUploads {
+ *   @IsArray()
+ *   @ArrayMaxLength(5)
+ *   files: UploadedFile[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - `maxLength: number` - The maximum number of elements allowed
+ *
+ * ### Validation Behavior
+ * - **Passes**: When array length <= maximum length
+ * - **Fails**: When array length > maximum length
+ * - **Edge cases**: Empty arrays always pass
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must not contain more than {maxLength} items"`
+ * - I18n key: `"validator.arrayMaxLength"`
+ *
+ * ### Performance
+ * - **O(1) operation**: Only checks array length property
+ * - Fast validation suitable for large arrays
+ *
+ * @param maxLength - Maximum number of elements allowed
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayMaxLength: (maxLength: number) => PropertyDecorator;
+/**
+ * ## ArrayLength Decorator
+ *
+ * Property decorator that validates an array has exactly the specified number of elements.
+ * Ensures arrays have a precise, required size for structured data requirements.
+ *
+ * ### Usage
+ * ```typescript
+ * class RGBColor {
+ *   @IsArray()
+ *   @ArrayLength(3)
+ *   @ArrayAllNumbers()
+ *   values: number[]; // [1, 2, 3]
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - `length: number` - The exact number of elements required
+ *
+ * ### Validation Behavior
+ * - **Passes**: When array length === exact length
+ * - **Fails**: When array length !== exact length
+ * - **Edge cases**: Empty arrays fail unless length is 0
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must contain exactly {length} items"`
+ * - I18n key: `"validator.arrayLength"`
+ *
+ * ### Performance
+ * - **O(1) operation**: Only checks array length property
+ * - Fast validation suitable for large arrays
+ *
+ * @param length - Exact number of elements required
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayLength: (length: number) => PropertyDecorator;
+/**
+ * ## ArrayContains Decorator
+ *
+ * Property decorator that validates an array contains all of the specified required values.
+ * Ensures that certain elements are present in the array for business logic requirements.
+ *
+ * ### Usage
+ * ```typescript
+ * class UserPermissions {
+ *   @IsArray()
+ *   @ArrayContains(["read", "write"])
+ *   permissions: string[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - `...requiredValues: any[]` - Values that must all be present in the array
+ *
+ * ### Validation Behavior
+ * - **Passes**: When array contains ALL specified values
+ * - **Fails**: When array is missing ANY specified value
+ * - **Comparison**: Uses deep equality checking for objects
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must contain all required values: {missingValues}"`
+ * - I18n key: `"validator.arrayContains"`
+ *
+ * ### Performance
+ * - **O(n*m) operation**: n = array length, m = required values length
+ * - May be slow for complex objects due to deep equality checking
+ *
+ * @param requiredValues - Values that must be present in the array
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayContains: (...ruleParameters: any[]) => PropertyDecorator;
+/**
+ * ## ArrayUnique Decorator
+ *
+ * Property decorator that validates all elements in an array are unique (no duplicates).
+ * Ensures arrays contain distinct values only, commonly used for IDs and identifiers.
+ *
+ * ### Usage
+ * ```typescript
+ * class UserIds {
+ *   @IsArray()
+ *   @ArrayUnique()
+ *   @ArrayAllStrings()
+ *   userIds: string[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - No parameters required
+ *
+ * ### Validation Behavior
+ * - **Passes**: When all array elements are unique
+ * - **Fails**: When any element appears more than once
+ * - **Empty/Single element arrays**: Always pass
+ *
+ * ### Uniqueness Checking
+ * - **Primitive types**: Compared by value
+ * - **Objects**: Compared by JSON string representation
+ * - **Null/undefined**: Treated as distinct values
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: Must contain only unique values"`
+ * - I18n key: `"validator.arrayUnique"`
+ *
+ * ### Performance
+ * - **O(n²) worst case**: Due to comparison operations
+ * - **Early exit**: Stops on first duplicate found
+ * - Uses Set for primitive type optimization
+ *
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayUnique: () => PropertyDecorator;
+/**
+ * ## ArrayAllStrings Decorator
+ *
+ * Property decorator that validates all elements in an array are strings.
+ * Ensures type homogeneity for string arrays used in text data collections.
+ *
+ * ### Usage
+ * ```typescript
+ * class TagList {
+ *   @IsArray()
+ *   @ArrayAllStrings()
+ *   @ArrayUnique()
+ *   tags: string[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - No parameters required
+ *
+ * ### Validation Behavior
+ * - **Passes**: When all elements are strings (including empty strings)
+ * - **Fails**: When any element is not a string
+ * - **Empty arrays**: Always pass
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: All items must be strings"`
+ * - I18n key: `"validator.arrayAllStrings"`
+ *
+ * ### Performance
+ * - **O(n) operation**: Iterates through all array elements
+ * - **Early exit**: Stops on first non-string element
+ * - Uses fast `typeof` operator
+ *
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayAllStrings: () => PropertyDecorator;
+/**
+ * ## ArrayAllNumbers Decorator
+ *
+ * Property decorator that validates all elements in an array are numbers.
+ * Ensures type homogeneity for numeric arrays used in data collections.
+ *
+ * ### Usage
+ * ```typescript
+ * class SensorReadings {
+ *   @IsArray()
+ *   @ArrayAllNumbers()
+ *   @ArrayMinLength(1)
+ *   values: number[];
+ * }
+ * ```
+ *
+ * ### Parameters
+ * - No parameters required
+ *
+ * ### Validation Behavior
+ * - **Passes**: When all elements are numbers (excluding NaN)
+ * - **Fails**: When any element is not a number or is NaN
+ * - **Empty arrays**: Always pass
+ *
+ * ### Number Type Considerations
+ * - **Valid**: `42`, `3.14`, `-0`, `Infinity`, `-Infinity`
+ * - **Invalid**: `NaN`, strings `"42"`, booleans, objects, null, undefined
+ *
+ * ### Error Messages
+ * - Default: `"[PropertyName]: All items must be numbers"`
+ * - I18n key: `"validator.arrayAllNumbers"`
+ *
+ * ### Performance
+ * - **O(n) operation**: Iterates through all array elements
+ * - **Early exit**: Stops on first invalid element
+ * - Uses fast `typeof` and `Number.isNaN` checks
+ *
+ * @returns A property decorator function
+ * @public
+ */
+export declare const ArrayAllNumbers: () => PropertyDecorator;
+declare module '../types' {
+    interface ValidatorRuleParamTypes {
+        /**
+         * ## Array Validation Rule
+         *
+         * Validates that a property value is an array. This is a fundamental array validation rule
+         * that ensures the value is actually an array before applying other array-specific validations.
+         *
+         * ### Purpose
+         * Ensures the property value is an array type before applying array-specific validation rules.
+         * This rule is typically used as a prerequisite for other array validation rules.
+         *
+         * ### Parameter Structure
+         * - **No parameters required**: `ValidatorRuleParams<[]>`
+         * - Rule takes no arguments: `"Array"`
+         *
+         * ### Usage Examples
+         *
+         * #### Basic Usage
+         * ```typescript
+         * class ProductList {
+         *   @IsArray()
+         *   products: Product[];
+         * }
+         * ```
+         *
+         * #### Combined with Other Array Rules
+         * ```typescript
+         * class UserRoles {
+         *   @IsArray()
+         *   @ArrayMinLength(1)
+         *   @ArrayAllStrings()
+         *   roles: string[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When value is an array (including empty arrays)
+         * - **Fails**: When value is not an array (null, undefined, object, string, number, etc.)
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must be an array"`
+         * - I18n key: `"validator.array"`
+         *
+         * ### Common Use Cases
+         * - Validating API responses that should return arrays
+         * - Ensuring form inputs that collect multiple values are arrays
+         * - Type guarding before applying array-specific operations
+         *
+         * ### Relationship to Other Rules
+         * - **Prerequisite for**: `ArrayMinLength`, `ArrayMaxLength`, `ArrayLength`, `ArrayContains`, `ArrayUnique`, `ArrayAllStrings`, `ArrayAllNumbers`
+         * - **Often combined with**: Array length and content validation rules
+         *
+         * @public
+         */
+        Array: ValidatorRuleParams<[]>;
+        /**
+         * ## Array Minimum Length Validation Rule
+         *
+         * Validates that an array has at least the specified minimum number of elements.
+         * This rule ensures arrays meet minimum size requirements.
+         *
+         * ### Purpose
+         * Enforces minimum array length constraints, commonly used for ensuring collections
+         * have sufficient elements for business logic requirements.
+         *
+         * ### Parameter Structure
+         * - **Single parameter**: `ValidatorRuleParams<[minLength: number]>`
+         * - **Parameter type**: `number` (minimum length required)
+         * - **Rule syntax**: `"ArrayMinLength[5]"` (minimum 5 elements)
+         *
+         * ### Usage Examples
+         *
+         * #### Basic Minimum Length
+         * ```typescript
+         * class ShoppingCart {
+         *   @IsArray()
+         *   @ArrayMinLength(1)
+         *   items: CartItem[];
+         * }
+         * ```
+         *
+         * #### Combined with Maximum Length
+         * ```typescript
+         * class TeamMembers {
+         *   @IsArray()
+         *   @ArrayMinLength(2)
+         *   @ArrayMaxLength(10)
+         *   members: User[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When array length >= minimum length
+         * - **Fails**: When array length < minimum length
+         * - **Edge cases**: Empty arrays fail if minLength > 0
+         *
+         * ### Parameter Validation
+         * - **Type checking**: Parameter must be a valid number
+         * - **Range validation**: Parameter must be >= 0
+         * - **Invalid parameters**: Throws error during rule parsing
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must contain at least {minLength} items"`
+         * - I18n key: `"validator.arrayMinLength"`
+         *
+         * ### Common Use Cases
+         * - Shopping carts requiring at least one item
+         * - Teams requiring minimum member counts
+         * - Collections needing baseline data
+         *
+         * ### Performance Notes
+         * - **O(1) operation**: Only checks array length property
+         * - **No iteration**: Does not traverse array elements
+         * - **Fast validation**: Suitable for large arrays
+         *
+         * @public
+         */
+        ArrayMinLength: ValidatorRuleParams<[minLength: number]>;
+        /**
+         * ## Array Maximum Length Validation Rule
+         *
+         * Validates that an array does not exceed the specified maximum number of elements.
+         * This rule prevents arrays from growing beyond acceptable limits.
+         *
+         * ### Purpose
+         * Enforces maximum array length constraints to prevent excessive data,
+         * memory issues, or performance problems with large collections.
+         *
+         * ### Parameter Structure
+         * - **Single parameter**: `ValidatorRuleParams<[maxLength: number]>`
+         * - **Parameter type**: `number` (maximum length allowed)
+         * - **Rule syntax**: `"ArrayMaxLength[100]"` (maximum 100 elements)
+         *
+         * ### Usage Examples
+         *
+         * #### Basic Maximum Length
+         * ```typescript
+         * class FileUploads {
+         *   @IsArray()
+         *   @ArrayMaxLength(5)
+         *   files: UploadedFile[];
+         * }
+         * ```
+         *
+         * #### Combined with Minimum Length
+         * ```typescript
+         * class CommitteeMembers {
+         *   @IsArray()
+         *   @ArrayMinLength(3)
+         *   @ArrayMaxLength(7)
+         *   members: Person[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When array length <= maximum length
+         * - **Fails**: When array length > maximum length
+         * - **Edge cases**: Empty arrays always pass
+         *
+         * ### Parameter Validation
+         * - **Type checking**: Parameter must be a valid number
+         * - **Range validation**: Parameter must be >= 0
+         * - **Invalid parameters**: Throws error during rule parsing
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must not contain more than {maxLength} items"`
+         * - I18n key: `"validator.arrayMaxLength"`
+         *
+         * ### Common Use Cases
+         * - Limiting file upload counts
+         * - Restricting participant numbers in events
+         * - Preventing memory issues with large datasets
+         * - Enforcing business rules on collection sizes
+         *
+         * ### Performance Notes
+         * - **O(1) operation**: Only checks array length property
+         * - **No iteration**: Does not traverse array elements
+         * - **Fast validation**: Suitable for large arrays
+         *
+         * @public
+         */
+        ArrayMaxLength: ValidatorRuleParams<[maxLength: number]>;
+        /**
+         * ## Array Exact Length Validation Rule
+         *
+         * Validates that an array has exactly the specified number of elements.
+         * This rule ensures arrays have a precise, required size.
+         *
+         * ### Purpose
+         * Enforces exact array length requirements where the number of elements
+         * must match a specific count exactly, not more or less.
+         *
+         * ### Parameter Structure
+         * - **Single parameter**: `ValidatorRuleParams<[length: number]>`
+         * - **Parameter type**: `number` (exact length required)
+         * - **Rule syntax**: `"ArrayLength[3]"` (exactly 3 elements required)
+         *
+         * ### Usage Examples
+         *
+         * #### Fixed-Size Collections
+         * ```typescript
+         * class RGBColor {
+         *   @IsArray()
+         *   @ArrayLength(3)
+         *   @ArrayAllNumbers()
+         *   values: number[]; // [r, g, b]
+         * }
+         * ```
+         *
+         * #### Structured Data Requirements
+         * ```typescript
+         * class Coordinate {
+         *   @IsArray()
+         *   @ArrayLength(2)
+         *   @ArrayAllNumbers()
+         *   point: number[]; // [x, y]
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When array length === exact length
+         * - **Fails**: When array length !== exact length
+         * - **Edge cases**: Empty arrays fail unless length is 0
+         *
+         * ### Parameter Validation
+         * - **Type checking**: Parameter must be a valid number
+         * - **Range validation**: Parameter must be >= 0
+         * - **Invalid parameters**: Throws error during rule parsing
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must contain exactly {length} items"`
+         * - I18n key: `"validator.arrayLength"`
+         *
+         * ### Common Use Cases
+         * - Color values requiring specific channel counts
+         * - Geographic coordinates with fixed dimensions
+         * - Structured data with known field counts
+         * - Protocol buffers or fixed-schema data structures
+         *
+         * ### Performance Notes
+         * - **O(1) operation**: Only checks array length property
+         * - **No iteration**: Does not traverse array elements
+         * - **Fast validation**: Suitable for large arrays
+         *
+         * ### Comparison with Range Rules
+         * | Rule | Use Case | Example |
+         * |------|----------|---------|
+         * | `ArrayLength` | Exact count required | RGB values: exactly 3 numbers |
+         * | `ArrayMinLength` + `ArrayMaxLength` | Size range allowed | Team: 2-10 members |
+         *
+         * @public
+         */
+        ArrayLength: ValidatorRuleParams<[length: number]>;
+        /**
+         * ## Array Contains Validation Rule
+         *
+         * Validates that an array contains all of the specified required values.
+         * This rule ensures that certain elements are present in the array.
+         *
+         * ### Purpose
+         * Ensures that an array includes specific required elements, commonly used
+         * for validating that collections contain mandatory items or meet inclusion criteria.
+         *
+         * ### Parameter Structure
+         * - **Array parameter**: `ValidatorRuleParams<any[]>`
+         * - **Parameter type**: `any[]` (array of values that must be present)
+         * - **Rule syntax**: `"ArrayContains[value1, value2, ...]"`
+         *
+         * ### Usage Examples
+         *
+         * #### Required Permissions
+         * ```typescript
+         * class UserPermissions {
+         *   @IsArray()
+         *   @ArrayContains(["read", "write"])
+         *   permissions: string[];
+         * }
+         * ```
+         *
+         * #### Mandatory Categories
+         * ```typescript
+         * class ProductTags {
+         *   @IsArray()
+         *   @ArrayContains(["electronics", "featured"])
+         *   tags: string[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When array contains ALL specified values
+         * - **Fails**: When array is missing ANY specified value
+         * - **Comparison**: Uses deep equality checking for objects
+         *
+         * ### Parameter Validation
+         * - **Type checking**: Parameter must be an array
+         * - **Empty arrays**: Valid but meaningless (no requirements)
+         * - **Invalid parameters**: Throws error during rule parsing
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must contain all required values: {missingValues}"`
+         * - I18n key: `"validator.arrayContains"`
+         *
+         * ### Common Use Cases
+         * - User permissions requiring specific access levels
+         * - Product categories needing mandatory tags
+         * - Configuration requiring essential settings
+         * - Business rules mandating certain options
+         *
+         * ### Performance Notes
+         * - **O(n*m) operation**: n = array length, m = required values length
+         * - **Nested loops**: Uses `some()` and `every()` for checking
+         * - **Deep equality**: May be slow for complex objects
+         *
+         * ### Important Considerations
+         * - **Deep equality**: Objects are compared by structure, not reference
+         * - **Primitive types**: Strings, numbers, booleans compared by value
+         * - **Null/undefined**: Treated as distinct values
+         * - **Order irrelevant**: Array order doesn't affect validation
+         *
+         * @public
+         */
+        ArrayContains: ValidatorRuleParams<any[]>;
+        /**
+         * ## Array Uniqueness Validation Rule
+         *
+         * Validates that all elements in an array are unique (no duplicates).
+         * This rule ensures arrays contain distinct values only.
+         *
+         * ### Purpose
+         * Prevents duplicate values in arrays where uniqueness is required,
+         * commonly used for IDs, usernames, email lists, or any collection
+         * where duplicates would cause issues.
+         *
+         * ### Parameter Structure
+         * - **No parameters required**: `ValidatorRuleParams<[]>`
+         * - Rule takes no arguments: `"ArrayUnique"`
+         *
+         * ### Usage Examples
+         *
+         * #### Unique Identifiers
+         * ```typescript
+         * class UserIds {
+         *   @IsArray()
+         *   @ArrayUnique()
+         *   @ArrayAllStrings()
+         *   userIds: string[];
+         * }
+         * ```
+         *
+         * #### Unique Email List
+         * ```typescript
+         * class InvitationList {
+         *   @IsArray()
+         *   @ArrayUnique()
+         *   @ArrayAllStrings()
+         *   emails: string[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When all array elements are unique
+         * - **Fails**: When any element appears more than once
+         * - **Empty arrays**: Always pass (no duplicates possible)
+         * - **Single element**: Always pass (no duplicates possible)
+         *
+         * ### Uniqueness Checking
+         * - **Primitive types**: Compared by value (string, number, boolean)
+         * - **Objects**: Compared by reference (not deep equality)
+         * - **Null/undefined**: Treated as distinct values
+         * - **Mixed types**: Different types are considered unique
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: Must contain only unique values"`
+         * - I18n key: `"validator.arrayUnique"`
+         *
+         * ### Common Use Cases
+         * - User ID collections
+         * - Email address lists
+         * - Tag collections
+         * - Primary key arrays
+         * - Selection lists without duplicates
+         *
+         * ### Performance Notes
+         * - **O(n²) worst case**: Nested loops for comparison
+         * - **Early exit**: Stops on first duplicate found
+         * - **Memory efficient**: Uses Set for primitive type optimization
+         * - **Object comparison**: Reference-based (fast but shallow)
+         *
+         * ### Important Considerations
+         * - **Object uniqueness**: Based on reference, not content
+         * - **Deep equality**: Not performed for performance reasons
+         * - **Custom comparison**: Not supported (use custom rule if needed)
+         * - **Case sensitivity**: String comparison is case-sensitive
+         *
+         * ### Alternatives for Complex Uniqueness
+         * For content-based uniqueness of objects, consider custom validation rules:
+         * ```typescript
+         * const uniqueByProperty = ({ value }) => {
+         *   const ids = value.map(item => item.id);
+         *   return ids.length === new Set(ids).size || "Duplicate IDs found";
+         * };
+         * ```
+         *
+         * @public
+         */
+        ArrayUnique: ValidatorRuleParams<[]>;
+        /**
+         * ## Array All Strings Validation Rule
+         *
+         * Validates that all elements in an array are strings.
+         * This rule ensures type homogeneity for string arrays.
+         *
+         * ### Purpose
+         * Enforces that array elements are exclusively strings, commonly used
+         * for validating collections of text data, identifiers, or labels.
+         *
+         * ### Parameter Structure
+         * - **No parameters required**: `ValidatorRuleParams<[]>`
+         * - Rule takes no arguments: `"ArrayAllStrings"`
+         *
+         * ### Usage Examples
+         *
+         * #### String Collections
+         * ```typescript
+         * class TagList {
+         *   @IsArray()
+         *   @ArrayAllStrings()
+         *   @ArrayUnique()
+         *   tags: string[];
+         * }
+         * ```
+         *
+         * #### User Input Arrays
+         * ```typescript
+         * class SearchKeywords {
+         *   @IsArray()
+         *   @ArrayAllStrings()
+         *   @ArrayMinLength(1)
+         *   keywords: string[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When all elements are strings (including empty strings)
+         * - **Fails**: When any element is not a string
+         * - **Empty arrays**: Always pass (no non-string elements)
+         * - **Type checking**: Uses `typeof item === 'string'`
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: All items must be strings"`
+         * - I18n key: `"validator.arrayAllStrings"`
+         *
+         * ### Common Use Cases
+         * - Tag collections
+         * - Keyword lists
+         * - User input arrays
+         * - Identifier collections
+         * - Text-based data arrays
+         *
+         * ### Performance Notes
+         * - **O(n) operation**: Iterates through all array elements
+         * - **Early exit**: Stops on first non-string element
+         * - **Type checking**: Uses fast `typeof` operator
+         *
+         * ### Related Rules
+         * - **ArrayAllNumbers**: For numeric arrays
+         * - **ArrayUnique**: For unique string arrays
+         * - **ArrayMinLength/ArrayMaxLength**: For size constraints
+         *
+         * @public
+         */
+        ArrayAllStrings: ValidatorRuleParams<[]>;
+        /**
+         * ## Array All Numbers Validation Rule
+         *
+         * Validates that all elements in an array are numbers.
+         * This rule ensures type homogeneity for numeric arrays.
+         *
+         * ### Purpose
+         * Enforces that array elements are exclusively numbers, commonly used
+         * for validating collections of numeric data, measurements, or calculations.
+         *
+         * ### Parameter Structure
+         * - **No parameters required**: `ValidatorRuleParams<[]>`
+         * - Rule takes no arguments: `"ArrayAllNumbers"`
+         *
+         * ### Usage Examples
+         *
+         * #### Numeric Data Collections
+         * ```typescript
+         * class SensorReadings {
+         *   @IsArray()
+         *   @ArrayAllNumbers()
+         *   @ArrayMinLength(1)
+         *   values: number[];
+         * }
+         * ```
+         *
+         * #### Coordinate Arrays
+         * ```typescript
+         * class PolygonPoints {
+         *   @IsArray()
+         *   @ArrayAllNumbers()
+         *   @ArrayLength(6) // [x1,y1,x2,y2,x3,y3]
+         *   coordinates: number[];
+         * }
+         * ```
+         *
+         * ### Validation Behavior
+         * - **Passes**: When all elements are numbers (including NaN, Infinity)
+         * - **Fails**: When any element is not a number
+         * - **Empty arrays**: Always pass (no non-number elements)
+         * - **Type checking**: Uses `typeof item === 'number'`
+         *
+         * ### Number Type Considerations
+         * - **Valid numbers**: `42`, `3.14`, `-0`, `NaN`, `Infinity`, `-Infinity`
+         * - **Invalid values**: Strings `"42"`, booleans, objects, null, undefined
+         * - **Numeric strings**: Not accepted (must be actual numbers)
+         *
+         * ### Error Messages
+         * - Default: `"[PropertyName]: All items must be numbers"`
+         * - I18n key: `"validator.arrayAllNumbers"`
+         *
+         * ### Common Use Cases
+         * - Sensor data collections
+         * - Measurement arrays
+         * - Coordinate systems
+         * - Statistical data
+         * - Mathematical calculations
+         *
+         * ### Performance Notes
+         * - **O(n) operation**: Iterates through all array elements
+         * - **Early exit**: Stops on first non-number element
+         * - **Type checking**: Uses fast `typeof` operator
+         *
+         * ### Related Rules
+         * - **ArrayAllStrings**: For string arrays
+         * - **ArrayUnique**: For unique number arrays
+         * - **ArrayMinLength/ArrayMaxLength**: For size constraints
+         * - **NumberGT/NumberLT**: For individual number validation
+         *
+         * ### Important Considerations
+         * - **NaN handling**: `NaN` values are considered valid numbers
+         * - **Infinity handling**: `Infinity` and `-Infinity` are valid numbers
+         * - **Type coercion**: No automatic conversion from strings to numbers
+         * - **Precision**: No validation of number precision or range
+         *
+         * @public
+         */
+        ArrayAllNumbers: ValidatorRuleParams<[]>;
+    }
+}