diff --git a/docs/2-features/03-validation.md b/docs/2-features/03-validation.md
index ccf70eab1..62b3c4956 100644
--- a/docs/2-features/03-validation.md
+++ b/docs/2-features/03-validation.md
@@ -11,13 +11,10 @@ While validation and [data mapping](./01-mapper) often work together, the two ar
 
 ## Validating against objects
 
-When you have raw data and an associated model or data transfer object, you may use the `validateValuesForClass` method on the {b`\Tempest\Validation\Validator`}.
+When you have raw data and an associated model or data transfer object, you may use the `validateValuesForClass()` method on the {b`\Tempest\Validation\Validator`}. Note that the validator needs to be [resolved from the container](../1-essentials/05-container.md#injecting-dependencies).
 
 ```php
-use Tempest\Validation\Validator;
-
-$validator = new Validator();
-$failingRules = $validator->validateValuesForClass(Book::class,  [
+$failingRules = $this->validator->validateValuesForClass(Book::class,  [
     'title' => 'Timeline Taxi',
     'description' => 'My sci-fi novel',
     'publishedAt' => '2024-10-01',
@@ -50,18 +47,20 @@ use Tempest\Validation\Rules;
 
 final class Book
 {
-    #[Rules\Length(min: 5, max: 50)]
+    #[Rules\HasLength(min: 5, max: 50)]
     public string $title;
 
-    #[Rules\NotEmpty]
+    #[Rules\IsNotEmptyString]
     public string $description;
 
-    #[Rules\DateTimeFormat('Y-m-d')]
+    #[Rules\HasDateTimeFormat('Y-m-d')]
     public ?DateTime $publishedAt = null;
 }
 ```
 
+:::info
 A list of all available validation rules can be found on [GitHub](https://github.com/tempestphp/tempest-framework/tree/main/packages/validation/src/Rules).
+:::
 
 ### Skipping validation
 
@@ -79,54 +78,70 @@ final class Book
 
 ## Validating against specific rules
 
-If you don't have a model or data transfer object to validate data against, you may alternatively use the `validateValues` and provide an array of rules.
+If you don't have a model or data transfer object to validate data against, you may alternatively use the `validateValues()` and provide an array of rules.
 
 ```php
-$validator->validateValues([
+$this->validator->validateValues([
     'name' => 'Jon Doe',
     'email' => 'jon@doe.co',
     'age' => 25,
 ], [
-    'name' => [new IsString(), new NotNull()],
-    'email' => [new Email()],
-    'age' => [new IsInteger(), new NotNull()],
+    'name' => [new IsString(), new IsNotNull()],
+    'email' => [new IsEmail()],
+    'age' => [new IsInteger(), new IsNotNull()],
 ]);
 ```
 
 If validation fails, `validateValues()` returns a list of fields and their respective failing rules.
 
+:::info
 A list of all available validation rules can be found on [GitHub](https://github.com/tempestphp/tempest-framework/tree/main/packages/validation/src/Rules).
+:::
 
 ## Validating a single value
 
-You may validate a single value against a set of rules using the `validateValue` method.
+You may validate a single value against a set of rules using the `validateValue()` method.
 
 ```php
-$validator->validateValue('jon@doe.co', [new Email()]);
+$this->validator->validateValue('jon@doe.co', [new IsEmail()]);
 ```
 
 Alternatively, you may provide a closure for validation. The closure should return `true` if validation passes, or `false` otherwise. You may also return a string to specify the validation failure message.
 
 ```php
-$validator->validateValue('jon@doe.co', function (mixed $value) {
+$this->validator->validateValue('jon@doe.co', function (mixed $value) {
     return str_contains($value, '@');
 });
 ```
 
 ## Accessing error messages
 
-When validation fails, a list of fields and their respective failing rules is returned. You may call the `message` method on any rule to get a validation message.
+When validation fails, a list of fields and their respective failing rules is returned. You may call the `getErrorMessage` method on the validator to get a [localized](./11-localization.md) validation message.
 
 ```php
 use Tempest\Support\Arr;
 
 // Validate some value
-$failures = $validator->validateValue('jon@doe.co', new Email());
+$failures = $this->validator->validateValue('jon@doe.co', new Email());
 
 // Map failures to their message
-$errors = Arr\map($failures, fn (Rule $failure) => $failure->message());
+$errors = Arr\map($failures, fn (Rule $failure) => $this->validator->getErrorMessage($failure));
 ```
 
-:::info
-Note that we expect to improve the way validation messages work in the future. See [this conversation](https://discord.com/channels/1236153076688359495/1294321824498323547/1294321824498323547) on our [Discord server](https://tempestphp.com/discord).
-:::
+You may also specify the field name of the validation failure to get a localized message for that field.
+
+```php
+$this->validator->getErrorMessage($failure, 'email');
+// => 'Email must be a valid email address'
+```
+
+## Overriding translation messages
+
+You may override the default validation messages by adding a [translation file](../2-features/11-localization.md#defining-translation-messages) anywhere in your codebase. Note that Tempest uses the [MessageFormat 2.0](https://messageformat.unicode.org/) format for localization.
+
+```php app/Localization/validation.en.yml
+validation_error:
+  is_email: |
+    .input {$field :string}
+    {$field} must be a valid email address.
+```
diff --git a/packages/console/src/Components/InteractiveComponentRenderer.php b/packages/console/src/Components/InteractiveComponentRenderer.php
index 92c65422a..4e117c7ca 100644
--- a/packages/console/src/Components/InteractiveComponentRenderer.php
+++ b/packages/console/src/Components/InteractiveComponentRenderer.php
@@ -11,10 +11,10 @@
 use Tempest\Console\InteractiveConsoleComponent;
 use Tempest\Console\Key;
 use Tempest\Console\Terminal\Terminal;
+use Tempest\Intl\Translator;
 use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\MethodReflector;
-use Tempest\Validation\Exceptions\ValueWasInvalid;
-use Tempest\Validation\Rule;
+use Tempest\Support\Arr;
 use Tempest\Validation\Validator;
 
 use function Tempest\Support\arr;
@@ -27,6 +27,10 @@ final class InteractiveComponentRenderer
 
     private bool $shouldRerender = true;
 
+    public function __construct(
+        private readonly Validator $validator,
+    ) {}
+
     public function render(Console $console, InteractiveConsoleComponent $component, array $validation = []): mixed
     {
         $clone = clone $this;
@@ -144,12 +148,12 @@ private function applyKey(InteractiveConsoleComponent $component, Console $conso
             // If something's returned, we'll need to validate the result
             $this->validationErrors = [];
 
-            $failingRule = $this->validate($return, $validation);
+            $validationError = $this->validate($return, $validation);
 
             // If invalid, we'll remember the validation message and continue
-            if ($failingRule !== null) {
+            if ($validationError !== null) {
                 $component->setState(ComponentState::ERROR);
-                $this->validationErrors[] = $failingRule->message();
+                $this->validationErrors[] = $validationError;
                 Fiber::suspend();
 
                 continue;
@@ -224,9 +228,17 @@ private function resolveHandlers(InteractiveConsoleComponent $component): array
     /**
      * @param \Tempest\Validation\Rule[] $validation
      */
-    private function validate(mixed $value, array $validation): ?Rule
+    private function validate(mixed $value, array $validation): ?string
     {
-        return new Validator()->validateValue($value, $validation)[0] ?? null;
+        $failingRules = $this->validator->validateValue($value, $validation);
+
+        if ($failingRules === []) {
+            return null;
+        }
+
+        return $this->validator->getErrorMessage(
+            rule: Arr\first($failingRules),
+        );
     }
 
     public function isComponentSupported(Console $console, InteractiveConsoleComponent $component): bool
diff --git a/packages/console/src/Middleware/InvalidCommandMiddleware.php b/packages/console/src/Middleware/InvalidCommandMiddleware.php
index 9910f8fe2..bdebee5cd 100644
--- a/packages/console/src/Middleware/InvalidCommandMiddleware.php
+++ b/packages/console/src/Middleware/InvalidCommandMiddleware.php
@@ -16,8 +16,8 @@
 use Tempest\Core\Priority;
 use Tempest\Validation\Rules\IsBoolean;
 use Tempest\Validation\Rules\IsEnum;
-use Tempest\Validation\Rules\NotEmpty;
-use Tempest\Validation\Rules\Numeric;
+use Tempest\Validation\Rules\IsNotEmptyString;
+use Tempest\Validation\Rules\IsNumeric;
 
 use function Tempest\Support\str;
 
@@ -70,10 +70,10 @@ private function retry(Invocation $invocation, InvalidCommandException $exceptio
                     validation: array_filter([
                         $isEnum
                             ? new IsEnum($argument->type)
-                            : new NotEmpty(),
+                            : new IsNotEmptyString(),
                         match ($argument->type) {
                             'bool' => new IsBoolean(),
-                            'int' => new Numeric(),
+                            'int' => new IsNumeric(),
                             default => null,
                         },
                     ]),
diff --git a/packages/core/src/PublishesFiles.php b/packages/core/src/PublishesFiles.php
index 155232afc..c1a3c01ff 100644
--- a/packages/core/src/PublishesFiles.php
+++ b/packages/core/src/PublishesFiles.php
@@ -21,7 +21,7 @@
 use Tempest\Support\Json;
 use Tempest\Support\Str\ImmutableString;
 use Tempest\Validation\Rules\EndsWith;
-use Tempest\Validation\Rules\NotEmpty;
+use Tempest\Validation\Rules\IsNotEmptyString;
 use Throwable;
 
 use function strlen;
@@ -174,7 +174,7 @@ public function promptTargetPath(string $suggestedPath, ?array $rules = null): s
         $targetPath = $this->console->ask(
             question: sprintf('Where do you want to save the file <em>%s</em>?', $className),
             default: to_relative_path(root_path(), $suggestedPath),
-            validation: $rules ?? [new NotEmpty(), new EndsWith('.php')],
+            validation: $rules ?? [new IsNotEmptyString(), new EndsWith('.php')],
         );
 
         return to_absolute_path(root_path(), $targetPath);
diff --git a/packages/database/src/Builder/ModelInspector.php b/packages/database/src/Builder/ModelInspector.php
index d824900d0..8fd3f9803 100644
--- a/packages/database/src/Builder/ModelInspector.php
+++ b/packages/database/src/Builder/ModelInspector.php
@@ -32,6 +32,10 @@ final class ModelInspector
 
     private(set) object|string $instance;
 
+    private Validator $validator {
+        get => get(Validator::class);
+    }
+
     public function __construct(
         private(set) object|string $model,
     ) {
@@ -344,7 +348,6 @@ public function validate(mixed ...$data): void
             return;
         }
 
-        $validator = new Validator();
         $failingRules = [];
 
         foreach ($data as $key => $value) {
@@ -354,7 +357,7 @@ public function validate(mixed ...$data): void
                 continue;
             }
 
-            $failingRulesForProperty = $validator->validateValueForProperty(
+            $failingRulesForProperty = $this->validator->validateValueForProperty(
                 $property,
                 $value,
             );
@@ -365,7 +368,7 @@ public function validate(mixed ...$data): void
         }
 
         if ($failingRules !== []) {
-            throw new ValidationFailed($this->reflector->getName(), $failingRules);
+            throw new ValidationFailed($failingRules, $this->reflector->getName());
         }
     }
 
diff --git a/packages/database/src/Commands/MakeMigrationCommand.php b/packages/database/src/Commands/MakeMigrationCommand.php
index 8f4672f34..91d56d7c7 100644
--- a/packages/database/src/Commands/MakeMigrationCommand.php
+++ b/packages/database/src/Commands/MakeMigrationCommand.php
@@ -16,7 +16,7 @@
 use Tempest\Generation\Exceptions\FileGenerationFailedException;
 use Tempest\Generation\Exceptions\FileGenerationWasAborted;
 use Tempest\Validation\Rules\EndsWith;
-use Tempest\Validation\Rules\NotEmpty;
+use Tempest\Validation\Rules\IsNotEmptyString;
 
 use function Tempest\Support\str;
 
@@ -74,7 +74,7 @@ private function generateRawFile(
             ->toString();
 
         $targetPath = $this->promptTargetPath($suggestedPath, rules: [
-            new NotEmpty(),
+            new IsNotEmptyString(),
             new EndsWith('.sql'),
         ]);
         $shouldOverride = $this->askForOverride($targetPath);
diff --git a/packages/database/src/Stubs/DatabaseModelStub.php b/packages/database/src/Stubs/DatabaseModelStub.php
index a6e37e357..88e723a35 100644
--- a/packages/database/src/Stubs/DatabaseModelStub.php
+++ b/packages/database/src/Stubs/DatabaseModelStub.php
@@ -5,14 +5,14 @@
 namespace Tempest\Database\Stubs;
 
 use Tempest\Database\IsDatabaseModel;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class DatabaseModelStub
 {
     use IsDatabaseModel;
 
     public function __construct(
-        #[Length(min: 1, max: 120)]
+        #[HasLength(min: 1, max: 120)]
         public string $title,
     ) {}
 }
diff --git a/packages/http/src/Mappers/PsrRequestToGenericRequestMapper.php b/packages/http/src/Mappers/PsrRequestToGenericRequestMapper.php
index 12f4ca66b..7bfd0d5cd 100644
--- a/packages/http/src/Mappers/PsrRequestToGenericRequestMapper.php
+++ b/packages/http/src/Mappers/PsrRequestToGenericRequestMapper.php
@@ -21,7 +21,7 @@
 final readonly class PsrRequestToGenericRequestMapper implements Mapper
 {
     public function __construct(
-        private readonly Encrypter $encrypter,
+        private Encrypter $encrypter,
     ) {}
 
     public function canMap(mixed $from, mixed $to): bool
diff --git a/packages/http/src/Mappers/RequestToObjectMapper.php b/packages/http/src/Mappers/RequestToObjectMapper.php
index 6b3dad6ee..6fc291d0a 100644
--- a/packages/http/src/Mappers/RequestToObjectMapper.php
+++ b/packages/http/src/Mappers/RequestToObjectMapper.php
@@ -19,6 +19,10 @@
 
 final readonly class RequestToObjectMapper implements Mapper
 {
+    public function __construct(
+        private Validator $validator,
+    ) {}
+
     public function canMap(mixed $from, mixed $to): bool
     {
         return $from instanceof Request;
@@ -53,10 +57,10 @@ public function map(mixed $from, mixed $to): array|object
             ];
         }
 
-        $failingRules = new Validator()->validateValuesForClass($to, $data);
+        $failingRules = $this->validator->validateValuesForClass($to, $data);
 
         if ($failingRules !== []) {
-            throw new ValidationFailed($from, $failingRules);
+            throw $this->validator->createValidationFailureException($failingRules, $from);
         }
 
         return map($data)->with(ArrayToObjectMapper::class)->to($to);
diff --git a/packages/http/src/Responses/Invalid.php b/packages/http/src/Responses/Invalid.php
index 295eaf611..15064994e 100644
--- a/packages/http/src/Responses/Invalid.php
+++ b/packages/http/src/Responses/Invalid.php
@@ -9,15 +9,22 @@
 use Tempest\Http\Response;
 use Tempest\Http\Session\Session;
 use Tempest\Http\Status;
+use Tempest\Intl\Translator;
 use Tempest\Support\Json;
 use Tempest\Validation\Rule;
+use Tempest\Validation\Validator;
 
+use function Tempest\get;
 use function Tempest\Support\arr;
 
 final class Invalid implements Response
 {
     use IsResponse;
 
+    public Validator $validator {
+        get => get(Validator::class);
+    }
+
     public function __construct(
         Request $request,
         /** @var \Tempest\Validation\Rule[][] $failingRules */
@@ -36,7 +43,7 @@ public function __construct(
             'x-validation',
             Json\encode(
                 arr($failingRules)->map(fn (array $failingRulesForField) => arr($failingRulesForField)->map(
-                    fn (Rule $rule) => $rule->message(),
+                    fn (Rule $rule) => $this->validator->getErrorMessage($rule),
                 )->toArray())->toArray(),
             ),
         );
diff --git a/packages/http/src/Stubs/RequestStub.php b/packages/http/src/Stubs/RequestStub.php
index 6b598b8e6..a06270d48 100644
--- a/packages/http/src/Stubs/RequestStub.php
+++ b/packages/http/src/Stubs/RequestStub.php
@@ -6,12 +6,12 @@
 
 use Tempest\Http\IsRequest;
 use Tempest\Http\Request;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class RequestStub implements Request
 {
     use IsRequest;
 
-    #[Length(min: 10, max: 120)]
+    #[HasLength(min: 10, max: 120)]
     public string $title;
 }
diff --git a/packages/intl/src/Catalog/CatalogInitializer.php b/packages/intl/src/Catalog/CatalogInitializer.php
index 19fcb3139..504810ea2 100644
--- a/packages/intl/src/Catalog/CatalogInitializer.php
+++ b/packages/intl/src/Catalog/CatalogInitializer.php
@@ -32,8 +32,8 @@ public function initialize(Container $container): Catalog
                     Str\ends_with($path, ['.yaml', '.yml']) => Yaml::parse($contents),
                 };
 
-                foreach (Arr\undot($messages) as $key => $message) {
-                    $catalog[$locale][$key] = $message;
+                foreach (Arr\dot($messages) as $key => $message) {
+                    $catalog[$locale] = Arr\set_by_key($catalog[$locale], $key, $message);
                 }
             }
         }
diff --git a/packages/intl/src/GenericTranslator.php b/packages/intl/src/GenericTranslator.php
index 9ee18608d..338f5eb85 100644
--- a/packages/intl/src/GenericTranslator.php
+++ b/packages/intl/src/GenericTranslator.php
@@ -33,7 +33,7 @@ public function translateForLocale(Locale $locale, string $key, mixed ...$argume
         }
 
         try {
-            return $this->formatter->format($message, ...$arguments);
+            return $this->formatter->format(mb_trim($message), ...$arguments);
         } catch (\Throwable $exception) {
             $this->eventBus?->dispatch(new TranslationFailure(
                 locale: $locale,
diff --git a/packages/intl/src/MessageFormat/Formatter/LocalVariable.php b/packages/intl/src/MessageFormat/Formatter/LocalVariable.php
index bf2845b47..d4cfb9b5e 100644
--- a/packages/intl/src/MessageFormat/Formatter/LocalVariable.php
+++ b/packages/intl/src/MessageFormat/Formatter/LocalVariable.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Intl\MessageFormat\Formatter;
 
+use Tempest\Intl\MessageFormat\FormattingFunction;
 use Tempest\Intl\MessageFormat\SelectorFunction;
 
 final readonly class LocalVariable
@@ -9,7 +10,8 @@
     public function __construct(
         public string $identifier,
         public mixed $value,
-        public ?SelectorFunction $function = null,
+        public ?SelectorFunction $selector = null,
+        public ?FormattingFunction $formatter = null,
         public array $parameters = [],
     ) {}
 }
diff --git a/packages/intl/src/MessageFormat/Formatter/MessageFormatter.php b/packages/intl/src/MessageFormat/Formatter/MessageFormatter.php
index 13546bf60..444bd968a 100644
--- a/packages/intl/src/MessageFormat/Formatter/MessageFormatter.php
+++ b/packages/intl/src/MessageFormat/Formatter/MessageFormatter.php
@@ -82,14 +82,27 @@ private function formatMessage(MessageNode $message): string
                     $variableName = $expression->variable->name->name;
 
                     if (! array_key_exists($variableName, $this->variables)) {
-                        throw new FormattingException("Required input variable `{$variableName}` not provided.");
+                        if ($declaration->optional) {
+                            $parameters = $this->evaluateOptions($expression->function?->options ?? []);
+
+                            $this->variables[$variableName] = new LocalVariable(
+                                identifier: $variableName,
+                                value: $parameters['default'],
+                                selector: $this->getSelectorFunction((string) $expression->function?->identifier),
+                                formatter: $this->getFormattingFunction((string) $expression->function?->identifier),
+                                parameters: $parameters,
+                            );
+                        } else {
+                            throw new FormattingException("Required input variable `{$variableName}` not provided.");
+                        }
                     }
 
                     if ($expression->function instanceof FunctionCall) {
                         $this->variables[$variableName] = new LocalVariable(
                             identifier: $variableName,
                             value: $this->variables[$variableName]->value,
-                            function: $this->getSelectorFunction((string) $expression->function->identifier),
+                            selector: $this->getSelectorFunction((string) $expression->function->identifier),
+                            formatter: $this->getFormattingFunction((string) $expression->function?->identifier),
                             parameters: $this->evaluateOptions($expression->function->options),
                         );
                     }
@@ -99,7 +112,8 @@ function: $this->getSelectorFunction((string) $expression->function->identifier)
                     $localVariables[$variableName] = new LocalVariable(
                         identifier: $variableName,
                         value: $this->evaluateExpression($declaration->expression)->value,
-                        function: $this->getSelectorFunction($declaration->expression->function?->identifier),
+                        selector: $this->getSelectorFunction($declaration->expression->function?->identifier),
+                        formatter: $this->getFormattingFunction($declaration->expression->function?->identifier),
                         parameters: $declaration->expression->attributes,
                     );
                 }
@@ -177,8 +191,8 @@ private function formatMatcher(Matcher $matcher): string
                 $variantKey = $keyNode->value;
                 $isMatch = false;
 
-                if ($variable->function) {
-                    $isMatch = $variable->function->match($variantKey, $variable->value, $variable->parameters);
+                if ($variable->selector) {
+                    $isMatch = $variable->selector->match($variantKey, $variable->value, $variable->parameters);
                 } else {
                     $isMatch = $variable->value === $variantKey;
                 }
@@ -248,6 +262,8 @@ private function formatPlaceholder(Placeholder $placeholder): string
     private function evaluateExpression(Expression $expression): FormattedValue
     {
         $value = null;
+        $formattingFunction = null;
+        $parameters = [];
 
         if ($expression instanceof LiteralExpression) {
             $value = $expression->literal->value;
@@ -259,26 +275,31 @@ private function evaluateExpression(Expression $expression): FormattedValue
             }
 
             $value = $this->variables[$variableName]->value;
+            $formattingFunction = $this->variables[$variableName]->formatter;
+            $parameters = $this->variables[$variableName]->parameters;
         } elseif ($expression instanceof FunctionExpression) {
             $value = null; // Function-only expressions start with null
         }
 
         if ($expression->function !== null) {
             $functionName = (string) $expression->function->identifier;
-            $options = $this->evaluateOptions($expression->function->options);
+            $parameters = $this->evaluateOptions($expression->function->options);
 
-            if ($function = $this->getFormattingFunction($functionName)) {
-                return $function->format($value, $options);
-            } else {
+            if (is_null($formattingFunction = $this->getFormattingFunction($functionName))) {
                 throw new FormattingException("Unknown function `{$functionName}`.");
             }
         }
 
-        $formatted = $value !== null ? ((string) $value) : '';
+        if ($formattingFunction) {
+            return $formattingFunction->format($value, $parameters);
+        }
 
-        return new FormattedValue($value, $formatted);
+        return new FormattedValue($value, $value !== null ? ((string) $value) : '');
     }
 
+    /**
+     * @param array<Option> $options
+     */
     private function evaluateOptions(array $options): array
     {
         $result = [];
diff --git a/packages/intl/src/MessageFormat/Functions/BooleanFunction.php b/packages/intl/src/MessageFormat/Functions/BooleanFunction.php
new file mode 100644
index 000000000..c8eb31dec
--- /dev/null
+++ b/packages/intl/src/MessageFormat/Functions/BooleanFunction.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Tempest\Intl\MessageFormat\Functions;
+
+use Tempest\Intl\MessageFormat\Formatter\FormattedValue;
+use Tempest\Intl\MessageFormat\FormattingFunction;
+use Tempest\Intl\MessageFormat\SelectorFunction;
+
+final class BooleanFunction implements SelectorFunction, FormattingFunction
+{
+    public string $name = 'boolean';
+
+    public function match(string $key, mixed $value, array $parameters): bool
+    {
+        return match ($value) {
+            [], null, false, 'false' => in_array($key, ['false', false, null, 'no', 0, '0'], strict: true),
+            default => in_array($key, ['true', true, 'yes', 1, '1'], strict: true),
+        };
+    }
+
+    public function format(mixed $value, array $parameters): FormattedValue
+    {
+        return new FormattedValue($value, match ($value) {
+            [], null, false, 'false' => 'false',
+            default => 'true',
+        });
+    }
+}
diff --git a/packages/intl/src/MessageFormat/Functions/DateTimeFunction.php b/packages/intl/src/MessageFormat/Functions/DateTimeFunction.php
index 53cc768aa..9e005dc06 100644
--- a/packages/intl/src/MessageFormat/Functions/DateTimeFunction.php
+++ b/packages/intl/src/MessageFormat/Functions/DateTimeFunction.php
@@ -2,7 +2,9 @@
 
 namespace Tempest\Intl\MessageFormat\Functions;
 
+use Tempest\DateTime\DateStyle;
 use Tempest\DateTime\DateTime;
+use Tempest\DateTime\TimeStyle;
 use Tempest\Intl\MessageFormat\Formatter\FormattedValue;
 use Tempest\Intl\MessageFormat\FormattingFunction;
 use Tempest\Support\Arr;
@@ -18,8 +20,32 @@ public function format(mixed $value, array $parameters): FormattedValue
         }
 
         $datetime = DateTime::parse($value);
-        $formatted = $datetime->format(Arr\get_by_key($parameters, 'pattern'));
 
-        return new FormattedValue($value, $formatted);
+        if ($pattern = Arr\get_by_key($parameters, 'pattern')) {
+            return new FormattedValue($value, $datetime->format($pattern));
+        }
+
+        return new FormattedValue(
+            value: $value,
+            formatted: $datetime->toString(
+                dateStyle: match (Arr\get_by_key($parameters, 'date_style')) {
+                    'full' => DateStyle::FULL,
+                    'long' => DateStyle::LONG,
+                    'medium' => DateStyle::MEDIUM,
+                    'short' => DateStyle::SHORT,
+                    'none' => DateStyle::NONE,
+                    'relative' => DateStyle::RELATIVE_MEDIUM,
+                    default => DateStyle::LONG,
+                },
+                timeStyle: match (Arr\get_by_key($parameters, 'time_style')) {
+                    'full' => TimeStyle::FULL,
+                    'long' => TimeStyle::LONG,
+                    'medium' => TimeStyle::MEDIUM,
+                    'short' => TimeStyle::SHORT,
+                    'none' => TimeStyle::NONE,
+                    default => TimeStyle::SHORT,
+                },
+            ),
+        );
     }
 }
diff --git a/packages/intl/src/MessageFormat/Functions/NumberFunction.php b/packages/intl/src/MessageFormat/Functions/NumberFunction.php
index 99c183d7b..ea048b645 100644
--- a/packages/intl/src/MessageFormat/Functions/NumberFunction.php
+++ b/packages/intl/src/MessageFormat/Functions/NumberFunction.php
@@ -11,7 +11,6 @@
 use Tempest\Intl\Number;
 use Tempest\Intl\PluralRules\PluralRulesMatcher;
 use Tempest\Support\Arr;
-use Tempest\Support\Str;
 
 final class NumberFunction implements FormattingFunction, SelectorFunction
 {
@@ -26,8 +25,12 @@ public function match(string $key, mixed $value, array $parameters): bool
     {
         $number = Number\parse($value);
 
+        if (Arr\get_by_key($parameters, 'select') === 'exists') {
+            return $this->matchExists($key, $value);
+        }
+
         if (Arr\get_by_key($parameters, 'select') === 'exact') {
-            return $key === Str\parse($value);
+            return Number\parse($key) === $value;
         }
 
         if (Number\parse($key) === $number || $key === $value) {
@@ -41,6 +44,19 @@ public function match(string $key, mixed $value, array $parameters): bool
         return false;
     }
 
+    private function matchExists(string $key, mixed $value): bool
+    {
+        if ($key === 'true') {
+            return $value !== null;
+        }
+
+        if ($key === 'false' || $key === 'null') {
+            return $value === null;
+        }
+
+        return false;
+    }
+
     public function format(mixed $value, array $parameters): FormattedValue
     {
         $number = Number\parse($value);
diff --git a/packages/intl/src/MessageFormat/Functions/StringFunction.php b/packages/intl/src/MessageFormat/Functions/StringFunction.php
index 62e406c72..81daf9e3e 100644
--- a/packages/intl/src/MessageFormat/Functions/StringFunction.php
+++ b/packages/intl/src/MessageFormat/Functions/StringFunction.php
@@ -19,7 +19,12 @@ public function match(string $key, mixed $value, array $parameters): bool
 
     public function format(mixed $value, array $parameters): FormattedValue
     {
-        $string = Str\parse($value, default: '');
+        $string = Str\parse($value, default: Arr\get_by_key($parameters, 'default', default: ''));
+
+        if (is_array($value)) {
+            $string = Arr\join($value, ', ', finalGlue: Arr\get_by_key($parameters, 'final_glue', default: ', '));
+        }
+
         $formatted = match (Arr\get_by_key($parameters, 'style')) {
             'uppercase', 'upper' => Str\to_upper_case($string),
             'lowercase', 'lower' => Str\to_lower_case($string),
diff --git a/packages/intl/src/MessageFormat/Parser/MessageFormatParser.php b/packages/intl/src/MessageFormat/Parser/MessageFormatParser.php
index 75475161e..ee00f5557 100644
--- a/packages/intl/src/MessageFormat/Parser/MessageFormatParser.php
+++ b/packages/intl/src/MessageFormat/Parser/MessageFormatParser.php
@@ -125,7 +125,14 @@ private function parseInputDeclaration(): InputDeclaration
         $this->consumeKeyword('.input');
         $this->consumeRequiredWhitespace();
 
-        return new InputDeclaration($this->parseVariableExpression());
+        $expression = $this->parseVariableExpression();
+
+        $optional = (bool) array_find(
+            array: $expression->function?->options ?? [],
+            callback: fn (Option $option) => $option->identifier->name === 'default' && ! is_null($option->value->value),
+        );
+
+        return new InputDeclaration($expression, $optional);
     }
 
     private function parseLocalDeclaration(): LocalDeclaration
diff --git a/packages/intl/src/MessageFormat/Parser/Node/Declaration/InputDeclaration.php b/packages/intl/src/MessageFormat/Parser/Node/Declaration/InputDeclaration.php
index c9e65c993..7c5b79e1c 100644
--- a/packages/intl/src/MessageFormat/Parser/Node/Declaration/InputDeclaration.php
+++ b/packages/intl/src/MessageFormat/Parser/Node/Declaration/InputDeclaration.php
@@ -8,5 +8,6 @@
 {
     public function __construct(
         public VariableExpression $expression,
+        public bool $optional,
     ) {}
 }
diff --git a/packages/intl/tests/FormatterTest.php b/packages/intl/tests/FormatterTest.php
index 953a3a9bc..4baf1b89f 100644
--- a/packages/intl/tests/FormatterTest.php
+++ b/packages/intl/tests/FormatterTest.php
@@ -76,7 +76,7 @@ public function test_format_number_function(): void
         $this->assertSame('The total was 31%.', $value);
     }
 
-    #[TestWith([0, "pas d'avion"])]
+    #[TestWith([0, 'pas d‘avion'])]
     #[TestWith([1, 'un avion'])]
     #[TestWith([5, '5 avions'])]
     public function test_match_number(int $count, string $expected): void
@@ -86,7 +86,7 @@ public function test_match_number(int $count, string $expected): void
         $value = $formatter->format(<<<'TXT'
         .input {$aircraft :number}
         .match $aircraft
-            0 {{pas d'avion}}
+            0 {{pas d‘avion}}
             1 {{un avion}}
             * {{{$aircraft} avions}}
         TXT, aircraft: $count);
@@ -94,6 +94,25 @@ public function test_match_number(int $count, string $expected): void
         $this->assertSame($expected, $value);
     }
 
+    public function test_default_input(): void
+    {
+        $formatter = new MessageFormatter([]);
+
+        $value = $formatter->format(<<<'TXT'
+        .input {$field :string default=unknown}
+        field is {$field}
+        TXT);
+
+        $this->assertSame('field is unknown', $value);
+
+        $value = $formatter->format(<<<'TXT'
+        .input {$field :string default=unknown}
+        field is {$field}
+        TXT, field: 'here');
+
+        $this->assertSame('field is here', $value);
+    }
+
     public function test_unquoted_text(): void
     {
         $formatter = new MessageFormatter();
@@ -273,7 +292,7 @@ public function test_string_function(): void
     #[TestWith(['value', 'value'])]
     #[TestWith([1, '1'])]
     #[TestWith([1.1, '1.1'])]
-    #[TestWith([['name' => 'Jon'], ''])]
+    #[TestWith([['name' => 'Jon'], 'Jon'])]
     public function test_string_formatting(mixed $input, string $expected): void
     {
         $formatter = new MessageFormatter([new StringFunction()]);
diff --git a/packages/mapper/src/Casters/DateTimeCaster.php b/packages/mapper/src/Casters/DateTimeCaster.php
index c359f6fa7..4ecf4088b 100644
--- a/packages/mapper/src/Casters/DateTimeCaster.php
+++ b/packages/mapper/src/Casters/DateTimeCaster.php
@@ -10,7 +10,7 @@
 use Tempest\DateTime\FormatPattern;
 use Tempest\Mapper\Caster;
 use Tempest\Reflection\PropertyReflector;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final readonly class DateTimeCaster implements Caster
 {
@@ -21,7 +21,7 @@ public function __construct(
     public static function fromProperty(PropertyReflector $property): self
     {
         return new self(
-            $property->getAttribute(DateTimeFormat::class)->format ?? FormatPattern::ISO8601,
+            $property->getAttribute(HasDateTimeFormat::class)->format ?? FormatPattern::ISO8601,
         );
     }
 
diff --git a/packages/mapper/src/Casters/NativeDateTimeCaster.php b/packages/mapper/src/Casters/NativeDateTimeCaster.php
index 489afb3a1..678784b06 100644
--- a/packages/mapper/src/Casters/NativeDateTimeCaster.php
+++ b/packages/mapper/src/Casters/NativeDateTimeCaster.php
@@ -9,7 +9,7 @@
 use DateTimeInterface;
 use Tempest\Mapper\Caster;
 use Tempest\Reflection\PropertyReflector;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final readonly class NativeDateTimeCaster implements Caster
 {
@@ -20,7 +20,7 @@ public function __construct(
 
     public static function fromProperty(PropertyReflector $property): NativeDateTimeCaster
     {
-        $format = $property->getAttribute(DateTimeFormat::class)->format ?? 'Y-m-d H:i:s';
+        $format = $property->getAttribute(HasDateTimeFormat::class)->format ?? 'Y-m-d H:i:s';
 
         return match ($property->getType()->getName()) {
             DateTime::class => new NativeDateTimeCaster($format, immutable: false),
diff --git a/packages/mapper/src/Serializers/DateTimeSerializer.php b/packages/mapper/src/Serializers/DateTimeSerializer.php
index 69bd543f3..03411c6f7 100644
--- a/packages/mapper/src/Serializers/DateTimeSerializer.php
+++ b/packages/mapper/src/Serializers/DateTimeSerializer.php
@@ -12,7 +12,7 @@
 use Tempest\Mapper\Serializer;
 use Tempest\Reflection\PropertyReflector;
 use Tempest\Reflection\TypeReflector;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final readonly class DateTimeSerializer implements Serializer
 {
@@ -23,7 +23,7 @@ public function __construct(
     public static function fromReflector(PropertyReflector|TypeReflector $reflector): self
     {
         if ($reflector instanceof PropertyReflector) {
-            $format = $reflector->getAttribute(DateTimeFormat::class)?->format ?? FormatPattern::SQL_DATE_TIME;
+            $format = $reflector->getAttribute(HasDateTimeFormat::class)?->format ?? FormatPattern::SQL_DATE_TIME;
         } else {
             $format = FormatPattern::SQL_DATE_TIME;
         }
diff --git a/packages/mapper/src/Serializers/NativeDateTimeSerializer.php b/packages/mapper/src/Serializers/NativeDateTimeSerializer.php
index 004998489..321d6775c 100644
--- a/packages/mapper/src/Serializers/NativeDateTimeSerializer.php
+++ b/packages/mapper/src/Serializers/NativeDateTimeSerializer.php
@@ -10,7 +10,7 @@
 use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\PropertyReflector;
 use Tempest\Reflection\TypeReflector;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final readonly class NativeDateTimeSerializer implements Serializer
 {
@@ -21,7 +21,7 @@ public function __construct(
     public static function fromReflector(PropertyReflector|TypeReflector $property): self
     {
         if ($property instanceof PropertyReflector) {
-            $format = $property->getAttribute(DateTimeFormat::class)?->format ?? 'Y-m-d H:i:s';
+            $format = $property->getAttribute(HasDateTimeFormat::class)?->format ?? 'Y-m-d H:i:s';
         } else {
             $format = 'Y-m-d H:i:s';
         }
diff --git a/packages/support/src/Str/ManipulatesString.php b/packages/support/src/Str/ManipulatesString.php
index 9bfefcf8a..c46c09b42 100644
--- a/packages/support/src/Str/ManipulatesString.php
+++ b/packages/support/src/Str/ManipulatesString.php
@@ -374,13 +374,7 @@ public function replaceStart(array|Stringable|string $search, Stringable|string
      */
     public function replaceEvery(array $replacements): self
     {
-        $haystack = $this->value;
-
-        foreach ($replacements as $needle => $replacement) {
-            $haystack = namespace\replace($this->value, $needle, (string) $replacement);
-        }
-
-        return $this->createOrModify($haystack);
+        return $this->createOrModify(namespace\replace_every($this->value, $replacements));
     }
 
     /**
diff --git a/packages/support/src/Str/functions.php b/packages/support/src/Str/functions.php
index d1d877d71..d99953f33 100644
--- a/packages/support/src/Str/functions.php
+++ b/packages/support/src/Str/functions.php
@@ -491,11 +491,13 @@ function replace_at(Stringable|string $string, int $position, int $length, Strin
      */
     function replace_every(Stringable|string $haystack, array $replacements): string
     {
+        $string = (string) $haystack;
+
         foreach ($replacements as $needle => $replacement) {
-            $haystack = namespace\replace($haystack, $needle, (string) $replacement);
+            $string = namespace\replace($string, $needle, (string) $replacement);
         }
 
-        return $haystack;
+        return $string;
     }
 
     /**
@@ -883,7 +885,7 @@ function equals(Stringable|string $string, string|Stringable $other): bool
     /**
      * Parses the given value to a string, returning the default value if it is not a string or `Stringable`.
      */
-    function parse(mixed $string, ?string $default = null): ?string
+    function parse(mixed $string, string $default = ''): string
     {
         if (is_string($string)) {
             return $string;
diff --git a/packages/support/tests/Str/FunctionsTest.php b/packages/support/tests/Str/FunctionsTest.php
index 8bea472a7..dec165d22 100644
--- a/packages/support/tests/Str/FunctionsTest.php
+++ b/packages/support/tests/Str/FunctionsTest.php
@@ -15,11 +15,11 @@ public function test_parse(): void
         $this->assertSame('foo', Str\parse('foo'));
         $this->assertSame('1', Str\parse('1'));
         $this->assertSame('1', Str\parse(1));
-        $this->assertSame(null, Str\parse(new stdClass()));
+        $this->assertSame('', Str\parse(new stdClass()));
         $this->assertSame('', Str\parse(new stdClass(), default: ''));
         $this->assertSame('foo', Str\parse(new stdClass(), default: 'foo'));
         $this->assertSame('foo', Str\parse(new MutableString('foo')));
         $this->assertSame('foo', Str\parse(new ImmutableString('foo')));
-        $this->assertSame(null, Str\parse(['a', 'b']));
+        $this->assertSame('', Str\parse(['a', 'b']));
     }
 }
diff --git a/packages/validation/composer.json b/packages/validation/composer.json
index 408f2b130..a04f34d07 100644
--- a/packages/validation/composer.json
+++ b/packages/validation/composer.json
@@ -9,6 +9,7 @@
         "giggsey/libphonenumber-for-php-lite": "^9.0",
         "tempest/reflection": "dev-main",
         "tempest/support": "dev-main",
+        "tempest/intl": "dev-main",
         "tempest/datetime": "dev-main"
     },
     "autoload": {
diff --git a/packages/validation/src/Exceptions/PropertyValidationFailed.php b/packages/validation/src/Exceptions/PropertyValidationFailed.php
index 3e7df38ac..b70909986 100644
--- a/packages/validation/src/Exceptions/PropertyValidationFailed.php
+++ b/packages/validation/src/Exceptions/PropertyValidationFailed.php
@@ -24,7 +24,7 @@ public function __construct(
 
         foreach ($this->failingRules as $key => $failingRulesForProperty) {
             foreach ($failingRulesForProperty as $failingRule) {
-                $messages[$key][] = arr($failingRule->message())->join()->toString();
+                $messages[$key][] = arr($failingRule->getTranslationVariables())->join()->toString();
             }
         }
 
diff --git a/packages/validation/src/Exceptions/ValidationFailed.php b/packages/validation/src/Exceptions/ValidationFailed.php
index a4c9cfa08..e38cb7e81 100644
--- a/packages/validation/src/Exceptions/ValidationFailed.php
+++ b/packages/validation/src/Exceptions/ValidationFailed.php
@@ -5,30 +5,24 @@
 namespace Tempest\Validation\Exceptions;
 
 use Exception;
-use Tempest\Support\Json;
 use Tempest\Validation\Rule;
 
-use function Tempest\Support\arr;
-
 final class ValidationFailed extends Exception
 {
+    /**
+     * @template TKey of array-key
+     *
+     * @param array<TKey,Rule[]> $failingRules
+     * @param array<TKey,string> $errorMessages
+     */
     public function __construct(
-        public readonly object|string $subject,
         public readonly array $failingRules,
+        public readonly null|object|string $subject = null,
+        public readonly array $errorMessages = [],
     ) {
-        $messages = [];
-
-        foreach ($this->failingRules as $field => $failingRulesForField) {
-            /** @var Rule $failingRuleForField */
-            foreach ($failingRulesForField as $failingRuleForField) {
-                $messages[$field][] = arr($failingRuleForField->message())->join()->toString();
-            }
-        }
-
-        if (is_object($subject)) {
-            $subject = $subject::class;
-        }
-
-        parent::__construct($subject . PHP_EOL . Json\encode($messages, pretty: true));
+        parent::__construct(match (true) {
+            is_null($subject) => 'Validation failed.',
+            default => sprintf('Validation failed for %s.', is_object($subject) ? $subject::class : $subject),
+        });
     }
 }
diff --git a/packages/validation/src/Exceptions/ValueWasInvalid.php b/packages/validation/src/Exceptions/ValueWasInvalid.php
index e94584d62..f54fb9582 100644
--- a/packages/validation/src/Exceptions/ValueWasInvalid.php
+++ b/packages/validation/src/Exceptions/ValueWasInvalid.php
@@ -5,7 +5,6 @@
 namespace Tempest\Validation\Exceptions;
 
 use Exception;
-use Tempest\Validation\Rule;
 
 final class ValueWasInvalid extends Exception
 {
diff --git a/packages/validation/src/HasErrorMessage.php b/packages/validation/src/HasErrorMessage.php
new file mode 100644
index 000000000..bd5ef64ce
--- /dev/null
+++ b/packages/validation/src/HasErrorMessage.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Tempest\Validation;
+
+interface HasErrorMessage
+{
+    /**
+     * Returns a plain-text validation error message.
+     */
+    public function getErrorMessage(): string;
+}
diff --git a/packages/validation/src/HasTranslationVariables.php b/packages/validation/src/HasTranslationVariables.php
new file mode 100644
index 000000000..88b61fb13
--- /dev/null
+++ b/packages/validation/src/HasTranslationVariables.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Tempest\Validation;
+
+interface HasTranslationVariables
+{
+    /**
+     * Returns variables used for translation validation error messages.
+     *
+     * @return array<string,mixed>
+     */
+    public function getTranslationVariables(): array;
+}
diff --git a/packages/validation/src/Rule.php b/packages/validation/src/Rule.php
index f4dd96a39..338b57a06 100644
--- a/packages/validation/src/Rule.php
+++ b/packages/validation/src/Rule.php
@@ -6,10 +6,8 @@
 
 interface Rule
 {
-    public function isValid(mixed $value): bool;
-
     /**
-     * @return string|string[]
+     * Determines whether the given value is valid for this rule.
      */
-    public function message(): string|array;
+    public function isValid(mixed $value): bool;
 }
diff --git a/packages/validation/src/Rules/DivisibleBy.php b/packages/validation/src/Rules/DivisibleBy.php
deleted file mode 100644
index bc42accf5..000000000
--- a/packages/validation/src/Rules/DivisibleBy.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class DivisibleBy implements Rule
-{
-    public function __construct(
-        public int $divisor,
-    ) {}
-
-    public function isValid(mixed $value): bool
-    {
-        if (! is_numeric($value) || $value === 0) {
-            return false;
-        }
-
-        return new MultipleOf($this->divisor)->isValid($value);
-    }
-
-    public function message(): string
-    {
-        return "Value should be divisible by {$this->divisor}";
-    }
-}
diff --git a/packages/validation/src/Rules/DoesNotEndWith.php b/packages/validation/src/Rules/DoesNotEndWith.php
index bee3e015b..c57623d99 100644
--- a/packages/validation/src/Rules/DoesNotEndWith.php
+++ b/packages/validation/src/Rules/DoesNotEndWith.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value does not end with a specified string.
+ */
 #[Attribute]
-final readonly class DoesNotEndWith implements Rule
+final readonly class DoesNotEndWith implements Rule, HasTranslationVariables
 {
     public function __construct(
         private string $needle,
@@ -19,8 +23,10 @@ public function isValid(mixed $value): bool
         return ! str_ends_with($value, $this->needle);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should not end with {$this->needle}";
+        return [
+            'needle' => $this->needle,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/DoesNotStartWith.php b/packages/validation/src/Rules/DoesNotStartWith.php
index 567194e38..812859201 100644
--- a/packages/validation/src/Rules/DoesNotStartWith.php
+++ b/packages/validation/src/Rules/DoesNotStartWith.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value does not start with a specified string.
+ */
 #[Attribute]
-final readonly class DoesNotStartWith implements Rule
+final readonly class DoesNotStartWith implements Rule, HasTranslationVariables
 {
     public function __construct(
         private string $needle,
@@ -19,8 +23,10 @@ public function isValid(mixed $value): bool
         return ! str_starts_with($value, $this->needle);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should not start with {$this->needle}";
+        return [
+            'needle' => $this->needle,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/EndsWith.php b/packages/validation/src/Rules/EndsWith.php
index 6c71e20cc..43f639eae 100644
--- a/packages/validation/src/Rules/EndsWith.php
+++ b/packages/validation/src/Rules/EndsWith.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value ends with a specified string.
+ */
 #[Attribute]
-final readonly class EndsWith implements Rule
+final readonly class EndsWith implements Rule, HasTranslationVariables
 {
     public function __construct(
         private string $needle,
@@ -19,8 +23,10 @@ public function isValid(mixed $value): bool
         return str_ends_with($value, $this->needle);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should end with {$this->needle}";
+        return [
+            'needle' => $this->needle,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Count.php b/packages/validation/src/Rules/HasCount.php
similarity index 62%
rename from packages/validation/src/Rules/Count.php
rename to packages/validation/src/Rules/HasCount.php
index 812be3188..7d2b91df3 100644
--- a/packages/validation/src/Rules/Count.php
+++ b/packages/validation/src/Rules/HasCount.php
@@ -6,10 +6,14 @@
 
 use Attribute;
 use InvalidArgumentException;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value (array or countable) has a specific count or falls within a count range.
+ */
 #[Attribute]
-final readonly class Count implements Rule
+final readonly class HasCount implements Rule, HasTranslationVariables
 {
     public function __construct(
         private ?int $min = null,
@@ -30,16 +34,11 @@ public function isValid(mixed $value): bool
         return $length >= $min && $length <= $max;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        if ($this->min && $this->max) {
-            return "Array should contain between {$this->min} and {$this->max} items";
-        }
-
-        if ($this->min) {
-            return "Array should contain no less than {$this->min} items";
-        }
-
-        return "Array should contain no more than {$this->max} items";
+        return [
+            'min' => $this->min,
+            'max' => $this->max,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/DateTimeFormat.php b/packages/validation/src/Rules/HasDateTimeFormat.php
similarity index 75%
rename from packages/validation/src/Rules/DateTimeFormat.php
rename to packages/validation/src/Rules/HasDateTimeFormat.php
index e6c8cff71..450c113fe 100644
--- a/packages/validation/src/Rules/DateTimeFormat.php
+++ b/packages/validation/src/Rules/HasDateTimeFormat.php
@@ -8,10 +8,14 @@
 use DateTimeImmutable as NativeDateTimeImmutable;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\FormatPattern;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid date string in a specified format.
+ */
 #[Attribute]
-final readonly class DateTimeFormat implements Rule
+final readonly class HasDateTimeFormat implements Rule, HasTranslationVariables
 {
     /**
      * @param string|FormatPattern $format An ICU or legacy datetime format ({@see https://unicode-org.github.io/icu/userguide/format_parse/datetime/#datetime-format-syntax}, {@see https://www.php.net/manual/en/datetime.format.php}).
@@ -47,8 +51,12 @@ private function validateNativeFormat(string $value): bool
         return $date->format($this->format) === $value;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should be a valid datetime in the format {$this->format}";
+        return [
+            'format' => ($this->format instanceof FormatPattern)
+                ? $this->format->value
+                : $this->format,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Length.php b/packages/validation/src/Rules/HasLength.php
similarity index 66%
rename from packages/validation/src/Rules/Length.php
rename to packages/validation/src/Rules/HasLength.php
index 19d96d5ea..78641575f 100644
--- a/packages/validation/src/Rules/Length.php
+++ b/packages/validation/src/Rules/HasLength.php
@@ -6,10 +6,14 @@
 
 use Attribute;
 use InvalidArgumentException;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value has a specific character length or falls within a length range.
+ */
 #[Attribute]
-final readonly class Length implements Rule
+final readonly class HasLength implements Rule, HasTranslationVariables
 {
     public function __construct(
         private ?int $min = null,
@@ -34,16 +38,11 @@ public function isValid(mixed $value): bool
         return $length >= $min && $length <= $max;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        if ($this->min && $this->max) {
-            return "Value should be between {$this->min} and {$this->max}";
-        }
-
-        if ($this->min) {
-            return "Value should be no less than {$this->min}";
-        }
-
-        return "Value should be no more than {$this->max}";
+        return [
+            'min' => $this->min,
+            'max' => $this->max,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/In.php b/packages/validation/src/Rules/In.php
deleted file mode 100644
index 7d01256c6..000000000
--- a/packages/validation/src/Rules/In.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class In implements Rule
-{
-    public function __construct(
-        /** @var array<string|int> */
-        private array $values,
-        private bool $not = false,
-    ) {}
-
-    public function isValid(mixed $value): bool
-    {
-        $isPartOf = in_array($value, $this->values, true);
-
-        return $this->not ? ! $isPartOf : $isPartOf;
-    }
-
-    public function message(): string
-    {
-        return 'Value should be one of: ' . implode(', ', $this->values);
-    }
-}
diff --git a/packages/validation/src/Rules/AfterDate.php b/packages/validation/src/Rules/IsAfterDate.php
similarity index 70%
rename from packages/validation/src/Rules/AfterDate.php
rename to packages/validation/src/Rules/IsAfterDate.php
index b7b86d396..e2e045c24 100644
--- a/packages/validation/src/Rules/AfterDate.php
+++ b/packages/validation/src/Rules/IsAfterDate.php
@@ -8,11 +8,15 @@
 use DateTimeInterface as NativeDateTimeInterface;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\DateTimeInterface;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 use Throwable;
 
+/**
+ * Validates that the value is a date that comes after a specified date.
+ */
 #[Attribute]
-final readonly class AfterDate implements Rule
+final readonly class IsAfterDate implements Rule, HasTranslationVariables
 {
     private DateTimeInterface $date;
 
@@ -38,16 +42,11 @@ public function isValid(mixed $value): bool
         return $value->after($this->date);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        $message[] = 'Value must be a date after';
-
-        if ($this->inclusive) {
-            $message[] = 'or equal to';
-        }
-
-        $message[] = $this->date->format();
-
-        return implode(' ', $message);
+        return [
+            'inclusive' => $this->inclusive,
+            'date' => $this->date,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Alpha.php b/packages/validation/src/Rules/IsAlpha.php
similarity index 67%
rename from packages/validation/src/Rules/Alpha.php
rename to packages/validation/src/Rules/IsAlpha.php
index c9974cdba..1ec1e19e7 100644
--- a/packages/validation/src/Rules/Alpha.php
+++ b/packages/validation/src/Rules/IsAlpha.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a string containing only alphabetic characters.
+ */
 #[Attribute]
-final readonly class Alpha implements Rule
+final readonly class IsAlpha implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -18,9 +21,4 @@ public function isValid(mixed $value): bool
 
         return boolval(preg_match('/^[A-Za-z]+$/', $value));
     }
-
-    public function message(): string
-    {
-        return 'Value should only contain alphabetic characters';
-    }
 }
diff --git a/packages/validation/src/Rules/AlphaNumeric.php b/packages/validation/src/Rules/IsAlphaNumeric.php
similarity index 65%
rename from packages/validation/src/Rules/AlphaNumeric.php
rename to packages/validation/src/Rules/IsAlphaNumeric.php
index 6673333a7..d16729239 100644
--- a/packages/validation/src/Rules/AlphaNumeric.php
+++ b/packages/validation/src/Rules/IsAlphaNumeric.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a string containing only alphabetic and numeric characters.
+ */
 #[Attribute]
-final readonly class AlphaNumeric implements Rule
+final readonly class IsAlphaNumeric implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -18,9 +21,4 @@ public function isValid(mixed $value): bool
 
         return boolval(preg_match('/^[A-Za-z0-9]+$/', $value));
     }
-
-    public function message(): string
-    {
-        return 'Value should only contain alphanumeric characters';
-    }
 }
diff --git a/packages/validation/src/Rules/ArrayList.php b/packages/validation/src/Rules/IsArrayList.php
similarity index 63%
rename from packages/validation/src/Rules/ArrayList.php
rename to packages/validation/src/Rules/IsArrayList.php
index cb5e0975b..95ebaf57f 100644
--- a/packages/validation/src/Rules/ArrayList.php
+++ b/packages/validation/src/Rules/IsArrayList.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is an array with consecutive integer keys starting from 0.
+ */
 #[Attribute]
-final readonly class ArrayList implements Rule
+final readonly class IsArrayList implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return is_array($value) && array_is_list($value);
     }
-
-    public function message(): string
-    {
-        return 'Value must be a list';
-    }
 }
diff --git a/packages/validation/src/Rules/BeforeDate.php b/packages/validation/src/Rules/IsBeforeDate.php
similarity index 70%
rename from packages/validation/src/Rules/BeforeDate.php
rename to packages/validation/src/Rules/IsBeforeDate.php
index 72d156b24..73c90026a 100644
--- a/packages/validation/src/Rules/BeforeDate.php
+++ b/packages/validation/src/Rules/IsBeforeDate.php
@@ -8,11 +8,15 @@
 use DateTimeInterface as NativeDateTimeInterface;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\DateTimeInterface;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 use Throwable;
 
+/**
+ * Validates that the value is a date that comes before a specified date.
+ */
 #[Attribute]
-final readonly class BeforeDate implements Rule
+final readonly class IsBeforeDate implements Rule, HasTranslationVariables
 {
     private DateTimeInterface $date;
 
@@ -38,16 +42,11 @@ public function isValid(mixed $value): bool
         return $value->before($this->date);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        $message[] = 'Value must be a date before';
-
-        if ($this->inclusive) {
-            $message[] = 'or equal to';
-        }
-
-        $message[] = $this->date->format();
-
-        return implode(' ', $message);
+        return [
+            'inclusive' => $this->inclusive,
+            'date' => $this->date,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Between.php b/packages/validation/src/Rules/IsBetween.php
similarity index 50%
rename from packages/validation/src/Rules/Between.php
rename to packages/validation/src/Rules/IsBetween.php
index ed436bfbc..0c514c336 100644
--- a/packages/validation/src/Rules/Between.php
+++ b/packages/validation/src/Rules/IsBetween.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is between a minimum and maximum number (inclusive).
+ */
 #[Attribute]
-final readonly class Between implements Rule
+final readonly class IsBetween implements Rule, HasTranslationVariables
 {
     public function __construct(
         private int $min,
@@ -20,8 +24,11 @@ public function isValid(mixed $value): bool
         return $value >= $this->min && $value <= $this->max;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should be between {$this->min} and {$this->max}";
+        return [
+            'min' => $this->min,
+            'max' => $this->max,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/BetweenDates.php b/packages/validation/src/Rules/IsBetweenDates.php
similarity index 71%
rename from packages/validation/src/Rules/BetweenDates.php
rename to packages/validation/src/Rules/IsBetweenDates.php
index 702d76654..7ba9a4d43 100644
--- a/packages/validation/src/Rules/BetweenDates.php
+++ b/packages/validation/src/Rules/IsBetweenDates.php
@@ -8,11 +8,15 @@
 use DateTimeInterface as NativeDateTimeInterface;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\DateTimeInterface;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 use Throwable;
 
+/**
+ * Validates that the value is a date that falls between two specified dates.
+ */
 #[Attribute]
-final readonly class BetweenDates implements Rule
+final readonly class IsBetweenDates implements Rule, HasTranslationVariables
 {
     private DateTimeInterface $first;
     private DateTimeInterface $second;
@@ -41,8 +45,12 @@ public function isValid(mixed $value): bool
         return $value->betweenTimeExclusive($this->first, $this->second);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value must be a date between {$this->first} and {$this->second}";
+        return [
+            'first' => $this->first,
+            'second' => $this->second,
+            'inclusive' => $this->inclusive,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IsBoolean.php b/packages/validation/src/Rules/IsBoolean.php
index 09e350a6c..a4d26123d 100644
--- a/packages/validation/src/Rules/IsBoolean.php
+++ b/packages/validation/src/Rules/IsBoolean.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a boolean or boolean-like value (truthy/falsy).
+ */
 #[Attribute]
-final readonly class IsBoolean implements Rule
+final readonly class IsBoolean implements Rule, HasTranslationVariables
 {
     public function __construct(
         private bool $orNull = false,
@@ -20,11 +24,13 @@ public function isValid(mixed $value): bool
             return true;
         }
 
-        return $value === false || $value === 'false' || $value === 0 || $value === '0' || $value === true || $value === 'true' || $value === 1 || $value === '1';
+        return new IsTruthy()->isValid($value) || new IsFalsy()->isValid($value);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should represent a boolean value';
+        return [
+            'or_null' => $this->orNull,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IsDivisibleBy.php b/packages/validation/src/Rules/IsDivisibleBy.php
new file mode 100644
index 000000000..6ae654dee
--- /dev/null
+++ b/packages/validation/src/Rules/IsDivisibleBy.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use Tempest\Validation\HasTranslationVariables;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is divisible by a specified number.
+ */
+#[Attribute]
+final readonly class IsDivisibleBy implements Rule, HasTranslationVariables
+{
+    public function __construct(
+        public int $divisor,
+    ) {}
+
+    public function isValid(mixed $value): bool
+    {
+        if (! is_numeric($value) || $value === 0) {
+            return false;
+        }
+
+        return new IsMultipleOf($this->divisor)->isValid($value);
+    }
+
+    public function getTranslationVariables(): array
+    {
+        return [
+            'divisor' => $this->divisor,
+        ];
+    }
+}
diff --git a/packages/validation/src/Rules/Email.php b/packages/validation/src/Rules/IsEmail.php
similarity index 79%
rename from packages/validation/src/Rules/Email.php
rename to packages/validation/src/Rules/IsEmail.php
index fb6efbae4..35f53fd38 100644
--- a/packages/validation/src/Rules/Email.php
+++ b/packages/validation/src/Rules/IsEmail.php
@@ -10,8 +10,11 @@
 use Egulias\EmailValidator\Validation\RFCValidation;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid email address.
+ */
 #[Attribute]
-final readonly class Email implements Rule
+final readonly class IsEmail implements Rule
 {
     public function __construct(
         private EmailValidation $validationMethod = new RFCValidation(),
@@ -23,9 +26,4 @@ public function isValid(mixed $value): bool
 
         return $emailValidator->isValid($value ?? '', $this->validationMethod);
     }
-
-    public function message(): string
-    {
-        return 'Value should be a valid email address';
-    }
 }
diff --git a/packages/validation/src/Rules/IsEnum.php b/packages/validation/src/Rules/IsEnum.php
index 3ce05e3e8..96af8d828 100644
--- a/packages/validation/src/Rules/IsEnum.php
+++ b/packages/validation/src/Rules/IsEnum.php
@@ -5,13 +5,23 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use BackedEnum;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 use UnexpectedValueException;
 use UnitEnum;
 
+use function Tempest\Support\arr;
+
+/**
+ * Validates that the value is a valid case of a specified enum.
+ */
 #[Attribute]
-final readonly class IsEnum implements Rule
+final readonly class IsEnum implements Rule, HasTranslationVariables
 {
+    /**
+     * @param class-string<UnitEnum|BackedEnum> $enum
+     */
     public function __construct(
         private string $enum,
         private array $only = [],
@@ -66,9 +76,19 @@ enum: $this->enum,
         );
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "The value must be a valid enumeration [{$this->enum}] case";
+        $values = arr($this->enum::cases())
+            ->filter(fn (UnitEnum $case) => $this->isDesirable($case))
+            ->map(static fn (UnitEnum $enum) => ($enum instanceof BackedEnum) ? $enum->value : $enum->name)
+            ->toArray();
+
+        return [
+            'enum' => $this->enum,
+            'values' => $values,
+            'only' => $this->only,
+            'except' => $this->except,
+        ];
     }
 
     private function isDesirable($value): bool
diff --git a/packages/validation/src/Rules/Even.php b/packages/validation/src/Rules/IsEvenNumber.php
similarity index 63%
rename from packages/validation/src/Rules/Even.php
rename to packages/validation/src/Rules/IsEvenNumber.php
index 60a583cd0..cf9688af3 100644
--- a/packages/validation/src/Rules/Even.php
+++ b/packages/validation/src/Rules/IsEvenNumber.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is an even integer.
+ */
 #[Attribute]
-final readonly class Even implements Rule
+final readonly class IsEvenNumber implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return is_int($value) && ($value % 2) === 0;
     }
-
-    public function message(): string
-    {
-        return 'Value should be an even number';
-    }
 }
diff --git a/packages/validation/src/Rules/IsFalsy.php b/packages/validation/src/Rules/IsFalsy.php
new file mode 100644
index 000000000..2bb3e80c5
--- /dev/null
+++ b/packages/validation/src/Rules/IsFalsy.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is a falsy value (false, 'false', 0, or '0').
+ */
+#[Attribute]
+final readonly class IsFalsy implements Rule
+{
+    public function isValid(mixed $value): bool
+    {
+        return in_array($value, [false, 'false', 0, '0', 'off', 'no', 'disabled'], strict: true);
+    }
+}
diff --git a/packages/validation/src/Rules/IsFloat.php b/packages/validation/src/Rules/IsFloat.php
index 49aa6b6b9..2391d6ebd 100644
--- a/packages/validation/src/Rules/IsFloat.php
+++ b/packages/validation/src/Rules/IsFloat.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a floating-point number.
+ */
 #[Attribute]
-final readonly class IsFloat implements Rule
+final readonly class IsFloat implements Rule, HasTranslationVariables
 {
     public function __construct(
         private bool $orNull = false,
@@ -28,8 +32,10 @@ public function isValid(mixed $value): bool
         return is_float($value) || floatval($value) == $value;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should be a float';
+        return [
+            'or_null' => $this->orNull,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/HexColor.php b/packages/validation/src/Rules/IsHexColor.php
similarity index 77%
rename from packages/validation/src/Rules/HexColor.php
rename to packages/validation/src/Rules/IsHexColor.php
index 3e998e400..3d174822d 100644
--- a/packages/validation/src/Rules/HexColor.php
+++ b/packages/validation/src/Rules/IsHexColor.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid hexadecimal color code.
+ */
 #[Attribute]
-final readonly class HexColor implements Rule
+final readonly class IsHexColor implements Rule
 {
     public function __construct(
         private bool $orNull = false,
@@ -26,9 +29,4 @@ public function isValid(mixed $value): bool
 
         return preg_match('/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/i', $value) === 1;
     }
-
-    public function message(): string
-    {
-        return 'Value should be a valid hexadecimal color.';
-    }
 }
diff --git a/packages/validation/src/Rules/IP.php b/packages/validation/src/Rules/IsIP.php
similarity index 61%
rename from packages/validation/src/Rules/IP.php
rename to packages/validation/src/Rules/IsIP.php
index 5dad886b1..53344fc22 100644
--- a/packages/validation/src/Rules/IP.php
+++ b/packages/validation/src/Rules/IsIP.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid IP address (IPv4 or IPv6).
+ */
 #[Attribute]
-final readonly class IP implements Rule
+final readonly class IsIP implements Rule, HasTranslationVariables
 {
     private int $options;
 
@@ -34,18 +38,11 @@ public function isValid(mixed $value): bool
         return boolval(filter_var($value, FILTER_VALIDATE_IP, $this->options));
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        $additions = [];
-
-        if ($this->options & FILTER_FLAG_NO_PRIV_RANGE) {
-            $additions[] = 'not in a private range';
-        }
-
-        if ($this->options & FILTER_FLAG_NO_RES_RANGE) {
-            $additions[] = 'not in a reserved range';
-        }
-
-        return 'Value should be a valid IP address' . ($additions === [] ? '' : (' that is ' . implode(' and ', $additions)));
+        return [
+            'allow_private_range' => $this->allowPrivateRange,
+            'allow_reserved_range' => $this->allowReservedRange,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IPv4.php b/packages/validation/src/Rules/IsIPv4.php
similarity index 60%
rename from packages/validation/src/Rules/IPv4.php
rename to packages/validation/src/Rules/IsIPv4.php
index bd28a3515..d3cb69471 100644
--- a/packages/validation/src/Rules/IPv4.php
+++ b/packages/validation/src/Rules/IsIPv4.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid IPv4 address.
+ */
 #[Attribute]
-final readonly class IPv4 implements Rule
+final readonly class IsIPv4 implements Rule, HasTranslationVariables
 {
     private int $options;
 
@@ -34,18 +38,11 @@ public function isValid(mixed $value): bool
         return boolval(filter_var($value, FILTER_VALIDATE_IP, $this->options));
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        $additions = [];
-
-        if ($this->options & FILTER_FLAG_NO_PRIV_RANGE) {
-            $additions[] = 'not in a private range';
-        }
-
-        if ($this->options & FILTER_FLAG_NO_RES_RANGE) {
-            $additions[] = 'not in a reserved range';
-        }
-
-        return 'Value should be a valid IPv4 address' . ($additions === [] ? '' : (' that is ' . implode(' and ', $additions)));
+        return [
+            'allow_private_range' => $this->allowPrivateRange,
+            'allow_reserved_range' => $this->allowReservedRange,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IPv6.php b/packages/validation/src/Rules/IsIPv6.php
similarity index 60%
rename from packages/validation/src/Rules/IPv6.php
rename to packages/validation/src/Rules/IsIPv6.php
index d570b1d2b..137abf070 100644
--- a/packages/validation/src/Rules/IPv6.php
+++ b/packages/validation/src/Rules/IsIPv6.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid IPv6 address.
+ */
 #[Attribute]
-final readonly class IPv6 implements Rule
+final readonly class IsIPv6 implements Rule, HasTranslationVariables
 {
     private int $options;
 
@@ -34,18 +38,11 @@ public function isValid(mixed $value): bool
         return boolval(filter_var($value, FILTER_VALIDATE_IP, $this->options));
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        $additions = [];
-
-        if ($this->options & FILTER_FLAG_NO_PRIV_RANGE) {
-            $additions[] = 'not in a private range';
-        }
-
-        if ($this->options & FILTER_FLAG_NO_RES_RANGE) {
-            $additions[] = 'not in a reserved range';
-        }
-
-        return 'Value should be a valid IPv6 address' . ($additions === [] ? '' : (' that is ' . implode(' and ', $additions)));
+        return [
+            'allow_private_range' => $this->allowPrivateRange,
+            'allow_reserved_range' => $this->allowReservedRange,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IsIn.php b/packages/validation/src/Rules/IsIn.php
new file mode 100644
index 000000000..74c1df3b1
--- /dev/null
+++ b/packages/validation/src/Rules/IsIn.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use Tempest\Validation\HasTranslationVariables;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is contained within a specified list of values.
+ */
+#[Attribute]
+final readonly class IsIn implements Rule, HasTranslationVariables
+{
+    public function __construct(
+        /** @var array<string|int> */
+        private array $values,
+        private bool $not = false,
+    ) {}
+
+    public function isValid(mixed $value): bool
+    {
+        $isPartOf = in_array($value, $this->values, strict: true);
+
+        return $this->not ? ! $isPartOf : $isPartOf;
+    }
+
+    public function getTranslationVariables(): array
+    {
+        return [
+            'values' => $this->values,
+            'not' => $this->not,
+        ];
+    }
+}
diff --git a/packages/validation/src/Rules/IsInteger.php b/packages/validation/src/Rules/IsInteger.php
index 1a8fbfc64..3177a684e 100644
--- a/packages/validation/src/Rules/IsInteger.php
+++ b/packages/validation/src/Rules/IsInteger.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is an integer.
+ */
 #[Attribute]
-final readonly class IsInteger implements Rule
+final readonly class IsInteger implements Rule, HasTranslationVariables
 {
     public function __construct(
         private bool $orNull = false,
@@ -28,8 +32,10 @@ public function isValid(mixed $value): bool
         return is_int($value) || intval($value) == $value;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should be an integer';
+        return [
+            'or_null' => $this->orNull,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Json.php b/packages/validation/src/Rules/IsJsonString.php
similarity index 79%
rename from packages/validation/src/Rules/Json.php
rename to packages/validation/src/Rules/IsJsonString.php
index 2a69c0eca..20ce516cc 100644
--- a/packages/validation/src/Rules/Json.php
+++ b/packages/validation/src/Rules/IsJsonString.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid JSON string.
+ */
 #[Attribute]
-final readonly class Json implements Rule
+final readonly class IsJsonString implements Rule
 {
     public function __construct(
         private ?int $depth = null,
@@ -29,9 +32,4 @@ public function isValid(mixed $value): bool
 
         return json_validate(...$arguments);
     }
-
-    public function message(): string
-    {
-        return 'Value should be a valid JSON string';
-    }
 }
diff --git a/packages/validation/src/Rules/Lowercase.php b/packages/validation/src/Rules/IsLowercase.php
similarity index 61%
rename from packages/validation/src/Rules/Lowercase.php
rename to packages/validation/src/Rules/IsLowercase.php
index 6554d6e7e..dc539597d 100644
--- a/packages/validation/src/Rules/Lowercase.php
+++ b/packages/validation/src/Rules/IsLowercase.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a lowercase string.
+ */
 #[Attribute]
-final readonly class Lowercase implements Rule
+final readonly class IsLowercase implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return $value === mb_strtolower($value);
     }
-
-    public function message(): string
-    {
-        return 'Value should be a lowercase string';
-    }
 }
diff --git a/packages/validation/src/Rules/MACAddress.php b/packages/validation/src/Rules/IsMacAddress.php
similarity index 62%
rename from packages/validation/src/Rules/MACAddress.php
rename to packages/validation/src/Rules/IsMacAddress.php
index 5a5ce379c..da4996856 100644
--- a/packages/validation/src/Rules/MACAddress.php
+++ b/packages/validation/src/Rules/IsMacAddress.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid MAC address.
+ */
 #[Attribute]
-final readonly class MACAddress implements Rule
+final readonly class IsMacAddress implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return boolval(filter_var($value, FILTER_VALIDATE_MAC));
     }
-
-    public function message(): string
-    {
-        return 'Value should be a valid MAC Address';
-    }
 }
diff --git a/packages/validation/src/Rules/MultipleOf.php b/packages/validation/src/Rules/IsMultipleOf.php
similarity index 51%
rename from packages/validation/src/Rules/MultipleOf.php
rename to packages/validation/src/Rules/IsMultipleOf.php
index 4d069a002..3a147a25b 100644
--- a/packages/validation/src/Rules/MultipleOf.php
+++ b/packages/validation/src/Rules/IsMultipleOf.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a multiple of a specified number.
+ */
 #[Attribute]
-final readonly class MultipleOf implements Rule
+final readonly class IsMultipleOf implements Rule, HasTranslationVariables
 {
     public function __construct(
         public int $divisor,
@@ -19,8 +23,10 @@ public function isValid(mixed $value): bool
         return is_int($value) && ($value % $this->divisor) === 0;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should be a multiple of ' . $this->divisor;
+        return [
+            'divisor' => $this->divisor,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/NotEmpty.php b/packages/validation/src/Rules/IsNotEmptyString.php
similarity index 61%
rename from packages/validation/src/Rules/NotEmpty.php
rename to packages/validation/src/Rules/IsNotEmptyString.php
index c409e0905..9264391d4 100644
--- a/packages/validation/src/Rules/NotEmpty.php
+++ b/packages/validation/src/Rules/IsNotEmptyString.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a non-empty string.
+ */
 #[Attribute]
-final readonly class NotEmpty implements Rule
+final readonly class IsNotEmptyString implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return is_string($value) && $value !== '';
     }
-
-    public function message(): string
-    {
-        return 'Value should be a non-empty string';
-    }
 }
diff --git a/packages/validation/src/Rules/IsNotIn.php b/packages/validation/src/Rules/IsNotIn.php
new file mode 100644
index 000000000..8da30d9bf
--- /dev/null
+++ b/packages/validation/src/Rules/IsNotIn.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use Tempest\Validation\HasTranslationVariables;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is not contained within a specified list of values.
+ */
+#[Attribute]
+final readonly class IsNotIn implements Rule, HasTranslationVariables
+{
+    public function __construct(
+        /** @var array<string|int> */
+        private array $values,
+    ) {}
+
+    public function isValid(mixed $value): bool
+    {
+        return new IsIn($this->values, not: true)->isValid($value);
+    }
+
+    public function getTranslationVariables(): array
+    {
+        return [
+            'values' => $this->values,
+        ];
+    }
+}
diff --git a/packages/validation/src/Rules/NotNull.php b/packages/validation/src/Rules/IsNotNull.php
similarity index 62%
rename from packages/validation/src/Rules/NotNull.php
rename to packages/validation/src/Rules/IsNotNull.php
index e584be348..ce57b1a6f 100644
--- a/packages/validation/src/Rules/NotNull.php
+++ b/packages/validation/src/Rules/IsNotNull.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is not null.
+ */
 #[Attribute]
-final readonly class NotNull implements Rule
+final readonly class IsNotNull implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return $value !== null;
     }
-
-    public function message(): string
-    {
-        return 'Value must not be null';
-    }
 }
diff --git a/packages/validation/src/Rules/Numeric.php b/packages/validation/src/Rules/IsNumeric.php
similarity index 66%
rename from packages/validation/src/Rules/Numeric.php
rename to packages/validation/src/Rules/IsNumeric.php
index c0b5dddc9..bbb3adcd0 100644
--- a/packages/validation/src/Rules/Numeric.php
+++ b/packages/validation/src/Rules/IsNumeric.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a string containing only numeric characters.
+ */
 #[Attribute]
-final readonly class Numeric implements Rule
+final readonly class IsNumeric implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -18,9 +21,4 @@ public function isValid(mixed $value): bool
 
         return boolval(preg_match('/^[0-9]+$/', $value));
     }
-
-    public function message(): string
-    {
-        return 'Value should only contain numeric characters';
-    }
 }
diff --git a/packages/validation/src/Rules/Odd.php b/packages/validation/src/Rules/IsOddNumber.php
similarity index 63%
rename from packages/validation/src/Rules/Odd.php
rename to packages/validation/src/Rules/IsOddNumber.php
index 28a8ce517..f1dcc4a8c 100644
--- a/packages/validation/src/Rules/Odd.php
+++ b/packages/validation/src/Rules/IsOddNumber.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is an odd integer.
+ */
 #[Attribute]
-final readonly class Odd implements Rule
+final readonly class IsOddNumber implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return is_int($value) && ($value % 2) !== 0;
     }
-
-    public function message(): string
-    {
-        return 'Value should be an odd number';
-    }
 }
diff --git a/packages/validation/src/Rules/Password.php b/packages/validation/src/Rules/IsPassword.php
similarity index 64%
rename from packages/validation/src/Rules/Password.php
rename to packages/validation/src/Rules/IsPassword.php
index 34a9ff0b4..1b723db05 100644
--- a/packages/validation/src/Rules/Password.php
+++ b/packages/validation/src/Rules/IsPassword.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value meets password strength requirements.
+ */
 #[Attribute]
-final readonly class Password implements Rule
+final readonly class IsPassword implements Rule, HasTranslationVariables
 {
     private int $min;
 
@@ -51,29 +55,14 @@ public function isValid(mixed $value): bool
         return true;
     }
 
-    /**
-     * @return string[]
-     */
-    public function message(): array
+    public function getTranslationVariables(): array
     {
-        $messages = ["Value should contain at least {$this->min} characters"];
-
-        if ($this->mixedCase) {
-            $messages[] = 'at least one uppercase and one lowercase letter';
-        }
-
-        if ($this->numbers) {
-            $messages[] = 'at least one number';
-        }
-
-        if ($this->letters) {
-            $messages[] = 'at least one letter';
-        }
-
-        if ($this->symbols) {
-            $messages[] = 'at least one symbol';
-        }
-
-        return $messages;
+        return [
+            'min' => $this->min,
+            'mixed_case' => $this->mixedCase,
+            'numbers' => $this->numbers,
+            'letters' => $this->letters,
+            'symbols' => $this->symbols,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/PhoneNumber.php b/packages/validation/src/Rules/IsPhoneNumber.php
similarity index 65%
rename from packages/validation/src/Rules/PhoneNumber.php
rename to packages/validation/src/Rules/IsPhoneNumber.php
index 4cfe2c20d..77875ebd1 100644
--- a/packages/validation/src/Rules/PhoneNumber.php
+++ b/packages/validation/src/Rules/IsPhoneNumber.php
@@ -6,11 +6,15 @@
 
 use Attribute;
 use libphonenumber\PhoneNumberUtil;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 use Throwable;
 
+/**
+ * Validates that the value is a valid phone number.
+ */
 #[Attribute]
-final readonly class PhoneNumber implements Rule
+final readonly class IsPhoneNumber implements Rule, HasTranslationVariables
 {
     public function __construct(
         private ?string $defaultRegion = null,
@@ -28,15 +32,10 @@ public function isValid(mixed $value): bool
         }
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        if (! $this->defaultRegion) {
-            return 'Value should be a valid phone number';
-        }
-
-        return sprintf(
-            'Value should be a valid %s phone number',
-            strtoupper($this->defaultRegion),
-        );
+        return [
+            'default_region' => $this->defaultRegion,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IsString.php b/packages/validation/src/Rules/IsString.php
index 9b59c5156..e03850b63 100644
--- a/packages/validation/src/Rules/IsString.php
+++ b/packages/validation/src/Rules/IsString.php
@@ -6,10 +6,14 @@
 
 use Attribute;
 use Stringable;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a string or stringable object.
+ */
 #[Attribute]
-final readonly class IsString implements Rule
+final readonly class IsString implements Rule, HasTranslationVariables
 {
     public function __construct(
         private bool $orNull = false,
@@ -28,8 +32,10 @@ public function isValid(mixed $value): bool
         return is_string($value);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should be a string';
+        return [
+            'or_null' => $this->orNull,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Time.php b/packages/validation/src/Rules/IsTime.php
similarity index 62%
rename from packages/validation/src/Rules/Time.php
rename to packages/validation/src/Rules/IsTime.php
index 77f689a40..3d41add97 100644
--- a/packages/validation/src/Rules/Time.php
+++ b/packages/validation/src/Rules/IsTime.php
@@ -5,13 +5,17 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid time format.
+ */
 #[Attribute]
-final readonly class Time implements Rule
+final readonly class IsTime implements Rule, HasTranslationVariables
 {
     public function __construct(
-        private bool $twentyFourHour = false,
+        private bool $twentyFourHour = true,
     ) {}
 
     public function isValid(mixed $value): bool
@@ -27,12 +31,10 @@ public function isValid(mixed $value): bool
         return preg_match('/^([0-1]?[0-9]):[0-5][0-9]\s([aApP].[mM].|[aApP][mM])$/', $value) === 1;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        if ($this->twentyFourHour) {
-            return 'Value should be a valid time in the 24-hour format of hh:mm';
-        }
-
-        return 'Value should be a valid time in the format of hh:mm xm';
+        return [
+            'twenty_four_hour' => $this->twentyFourHour,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/IsTimezone.php b/packages/validation/src/Rules/IsTimezone.php
new file mode 100644
index 000000000..47355b531
--- /dev/null
+++ b/packages/validation/src/Rules/IsTimezone.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use DateTimeZone;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is a valid timezone identifier.
+ */
+#[Attribute]
+final readonly class IsTimezone implements Rule
+{
+    /**
+     * Ensures that the value is a valid timezone, optionally filtered by a specific timezone group or country code.
+     *
+     * @param int $timezoneGroup A {@see \DateTimeZone} group.
+     * @param string|null $countryCode A two-letter ISO 3166-1 compatible country code. Only used when filtering per country.
+     */
+    public function __construct(
+        private int $timezoneGroup = DateTimeZone::ALL,
+        private ?string $countryCode = null,
+    ) {}
+
+    public function isValid(mixed $value): bool
+    {
+        return in_array(
+            needle: $value,
+            haystack: timezone_identifiers_list($this->timezoneGroup, $this->countryCode),
+            strict: true,
+        );
+    }
+}
diff --git a/packages/validation/src/Rules/IsTruthy.php b/packages/validation/src/Rules/IsTruthy.php
new file mode 100644
index 000000000..97bdee895
--- /dev/null
+++ b/packages/validation/src/Rules/IsTruthy.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Rules;
+
+use Attribute;
+use Tempest\Validation\Rule;
+
+/**
+ * Validates that the value is a truthy value (true, 'true', 1, or '1').
+ */
+#[Attribute]
+final readonly class IsTruthy implements Rule
+{
+    public function isValid(mixed $value): bool
+    {
+        return in_array($value, [true, 'true', 1, '1', 'on', 'yes', 'enabled'], strict: true);
+    }
+}
diff --git a/packages/validation/src/Rules/Ulid.php b/packages/validation/src/Rules/IsUlid.php
similarity index 54%
rename from packages/validation/src/Rules/Ulid.php
rename to packages/validation/src/Rules/IsUlid.php
index b51082cdd..03d3b6a21 100644
--- a/packages/validation/src/Rules/Ulid.php
+++ b/packages/validation/src/Rules/IsUlid.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Support\Random;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid ULID (universally unique lexicographically sortable identifier).
+ */
 #[Attribute]
-final readonly class Ulid implements Rule
+final readonly class IsUlid implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -16,11 +20,6 @@ public function isValid(mixed $value): bool
             return false;
         }
 
-        return preg_match('/^[0-9A-HJKMNP-TV-Z]{26}$/i', $value) === 1;
-    }
-
-    public function message(): string
-    {
-        return 'Value should be a valid ULID';
+        return Random\is_ulid($value);
     }
 }
diff --git a/packages/validation/src/Rules/Timestamp.php b/packages/validation/src/Rules/IsUnixTimestamp.php
similarity index 69%
rename from packages/validation/src/Rules/Timestamp.php
rename to packages/validation/src/Rules/IsUnixTimestamp.php
index 1cab531ac..1bbfd5acb 100644
--- a/packages/validation/src/Rules/Timestamp.php
+++ b/packages/validation/src/Rules/IsUnixTimestamp.php
@@ -7,8 +7,11 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid Unix timestamp.
+ */
 #[Attribute]
-final readonly class Timestamp implements Rule
+final readonly class IsUnixTimestamp implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -18,9 +21,4 @@ public function isValid(mixed $value): bool
 
         return (bool) date('Y-m-d H:i:s', $value);
     }
-
-    public function message(): string
-    {
-        return 'Value should be a valid timestamp';
-    }
 }
diff --git a/packages/validation/src/Rules/Uppercase.php b/packages/validation/src/Rules/IsUppercase.php
similarity index 61%
rename from packages/validation/src/Rules/Uppercase.php
rename to packages/validation/src/Rules/IsUppercase.php
index bbeff6391..3bc8883d9 100644
--- a/packages/validation/src/Rules/Uppercase.php
+++ b/packages/validation/src/Rules/IsUppercase.php
@@ -7,16 +7,14 @@
 use Attribute;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is an uppercase string.
+ */
 #[Attribute]
-final readonly class Uppercase implements Rule
+final readonly class IsUppercase implements Rule
 {
     public function isValid(mixed $value): bool
     {
         return $value === mb_strtoupper($value);
     }
-
-    public function message(): string
-    {
-        return 'Value should be an uppercase string';
-    }
 }
diff --git a/packages/validation/src/Rules/Url.php b/packages/validation/src/Rules/IsUrl.php
similarity index 95%
rename from packages/validation/src/Rules/Url.php
rename to packages/validation/src/Rules/IsUrl.php
index 6bdcbde0f..090cea40c 100644
--- a/packages/validation/src/Rules/Url.php
+++ b/packages/validation/src/Rules/IsUrl.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid URL.
+ */
 #[Attribute]
-final readonly class Url implements Rule
+final readonly class IsUrl implements Rule, HasTranslationVariables
 {
     /**
      * @param string[] $protocols
@@ -66,8 +70,10 @@ public function isValid(mixed $value): bool
         return preg_match(sprintf($pattern, $protocolList), $value) === 1;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return 'Value should be a valid URL';
+        return [
+            'protocols' => $this->protocols,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Uuid.php b/packages/validation/src/Rules/IsUuid.php
similarity index 69%
rename from packages/validation/src/Rules/Uuid.php
rename to packages/validation/src/Rules/IsUuid.php
index 9db6b77eb..e09335bc6 100644
--- a/packages/validation/src/Rules/Uuid.php
+++ b/packages/validation/src/Rules/IsUuid.php
@@ -8,8 +8,11 @@
 use Tempest\Support\Random;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value is a valid UUID (universally unique identifier).
+ */
 #[Attribute]
-final readonly class Uuid implements Rule
+final readonly class IsUuid implements Rule
 {
     public function isValid(mixed $value): bool
     {
@@ -19,9 +22,4 @@ public function isValid(mixed $value): bool
 
         return Random\is_uuid($value);
     }
-
-    public function message(): string
-    {
-        return 'Value should contain a valid UUID';
-    }
 }
diff --git a/packages/validation/src/Rules/RegEx.php b/packages/validation/src/Rules/MatchesRegEx.php
similarity index 55%
rename from packages/validation/src/Rules/RegEx.php
rename to packages/validation/src/Rules/MatchesRegEx.php
index 466a61b52..73eb84d43 100644
--- a/packages/validation/src/Rules/RegEx.php
+++ b/packages/validation/src/Rules/MatchesRegEx.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value matches a specified regular expression pattern.
+ */
 #[Attribute]
-final readonly class RegEx implements Rule
+final readonly class MatchesRegEx implements Rule, HasTranslationVariables
 {
     public function __construct(
         private string $pattern,
@@ -23,8 +27,10 @@ public function isValid(mixed $value): bool
         return preg_match($this->pattern, $value) === 1;
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "The value must match the regular expression pattern: {$this->pattern}";
+        return [
+            'pattern' => $this->pattern,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/NotIn.php b/packages/validation/src/Rules/NotIn.php
deleted file mode 100644
index 16e4b355a..000000000
--- a/packages/validation/src/Rules/NotIn.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class NotIn implements Rule
-{
-    public function __construct(
-        /** @var array<string|int> */
-        private array $values,
-    ) {}
-
-    public function isValid(mixed $value): bool
-    {
-        return new In($this->values, true)->isValid($value);
-    }
-
-    public function message(): string
-    {
-        return 'Value cannot be any of: ' . implode(', ', $this->values);
-    }
-}
diff --git a/packages/validation/src/Rules/ShouldBeFalse.php b/packages/validation/src/Rules/ShouldBeFalse.php
deleted file mode 100644
index 2ed149935..000000000
--- a/packages/validation/src/Rules/ShouldBeFalse.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class ShouldBeFalse implements Rule
-{
-    public function isValid(mixed $value): bool
-    {
-        return $value === false || $value === 'false' || $value === 0 || $value === '0';
-    }
-
-    public function message(): string
-    {
-        return 'Value should represent a boolean false value.';
-    }
-}
diff --git a/packages/validation/src/Rules/ShouldBeTrue.php b/packages/validation/src/Rules/ShouldBeTrue.php
deleted file mode 100644
index a23236ac8..000000000
--- a/packages/validation/src/Rules/ShouldBeTrue.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class ShouldBeTrue implements Rule
-{
-    public function isValid(mixed $value): bool
-    {
-        return $value === true || $value === 'true' || $value === 1 || $value === '1';
-    }
-
-    public function message(): string
-    {
-        return 'Value should represent a boolean true value.';
-    }
-}
diff --git a/packages/validation/src/Rules/StartsWith.php b/packages/validation/src/Rules/StartsWith.php
index 6d10642e6..88621a798 100644
--- a/packages/validation/src/Rules/StartsWith.php
+++ b/packages/validation/src/Rules/StartsWith.php
@@ -5,10 +5,14 @@
 namespace Tempest\Validation\Rules;
 
 use Attribute;
+use Tempest\Validation\HasTranslationVariables;
 use Tempest\Validation\Rule;
 
+/**
+ * Validates that the value starts with a specified string.
+ */
 #[Attribute]
-final readonly class StartsWith implements Rule
+final readonly class StartsWith implements Rule, HasTranslationVariables
 {
     public function __construct(
         private string $needle,
@@ -19,8 +23,10 @@ public function isValid(mixed $value): bool
         return str_starts_with($value, $this->needle);
     }
 
-    public function message(): string
+    public function getTranslationVariables(): array
     {
-        return "Value should start with {$this->needle}";
+        return [
+            'needle' => $this->needle,
+        ];
     }
 }
diff --git a/packages/validation/src/Rules/Timezone.php b/packages/validation/src/Rules/Timezone.php
deleted file mode 100644
index c008b65d9..000000000
--- a/packages/validation/src/Rules/Timezone.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Rules;
-
-use Attribute;
-use DateTimeZone;
-use Tempest\Validation\Rule;
-
-#[Attribute]
-final readonly class Timezone implements Rule
-{
-    public function __construct(
-        private int $timezoneGroup = DateTimeZone::ALL,
-        private ?string $countryCode = null,
-    ) {}
-
-    public function isValid(mixed $value): bool
-    {
-        $timezones = timezone_identifiers_list($this->timezoneGroup, $this->countryCode);
-
-        return in_array($value, $timezones, strict: true);
-    }
-
-    public function message(): string
-    {
-        return 'Value should be a valid timezone';
-    }
-}
diff --git a/packages/validation/src/Validator.php b/packages/validation/src/Validator.php
index 4dd24a5ec..bf4b1a2a2 100644
--- a/packages/validation/src/Validator.php
+++ b/packages/validation/src/Validator.php
@@ -5,20 +5,30 @@
 namespace Tempest\Validation;
 
 use Closure;
+use Tempest\Container\Singleton;
+use Tempest\Intl\Catalog\Catalog;
+use Tempest\Intl\Translator;
 use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\PropertyReflector;
+use Tempest\Support\Arr;
 use Tempest\Validation\Exceptions\ValidationFailed;
 use Tempest\Validation\Rules\IsBoolean;
 use Tempest\Validation\Rules\IsEnum;
 use Tempest\Validation\Rules\IsFloat;
 use Tempest\Validation\Rules\IsInteger;
+use Tempest\Validation\Rules\IsNotNull;
 use Tempest\Validation\Rules\IsString;
-use Tempest\Validation\Rules\NotNull;
 
 use function Tempest\Support\arr;
+use function Tempest\Support\str;
 
+#[Singleton]
 final readonly class Validator
 {
+    public function __construct(
+        private Translator $translator,
+    ) {}
+
     /**
      * Validates the values of public properties on the specified object using attribute rules.
      */
@@ -39,14 +49,27 @@ public function validateObject(object $object): void
         }
 
         if ($failingRules !== []) {
-            throw new ValidationFailed($object, $failingRules);
+            throw $this->createValidationFailureException($failingRules, $object);
         }
     }
 
+    /**
+     * Creates a {@see ValidationFailed} exception from the given rule failures, populated with error messages.
+     *
+     * @param array<string,Rule[]> $failingRules
+     */
+    public function createValidationFailureException(array $failingRules, null|object|string $subject = null): ValidationFailed
+    {
+        return new ValidationFailed($failingRules, $subject, Arr\map_iterable($failingRules, function (array $rules, string $field) {
+            return Arr\map_iterable($rules, fn (Rule $rule) => $this->getErrorMessage($rule, $field));
+        }));
+    }
+
     /**
      * Validates the specified `$values` for the corresponding public properties on the specified `$class`, using built-in PHP types and attribute rules.
      *
      * @param ClassReflector|class-string $class
+     * @return Rule[]
      */
     public function validateValuesForClass(ClassReflector|string $class, ?array $values, string $prefix = ''): array
     {
@@ -96,6 +119,8 @@ class: $property->getType()->asClass(),
 
     /**
      * Validates `$value` against the specified `$property`, using built-in PHP types and attribute rules.
+     *
+     * @return Rule[]
      */
     public function validateValueForProperty(PropertyReflector $property, mixed $value): array
     {
@@ -111,7 +136,7 @@ public function validateValueForProperty(PropertyReflector $property, mixed $val
             };
         } elseif (! $property->isNullable()) {
             // We only add the NotNull rule if we're not dealing with scalar types, since the null check is included in the scalar rules
-            $rules[] = new NotNull();
+            $rules[] = new IsNotNull();
         }
 
         if ($property->getType()->isEnum()) {
@@ -122,13 +147,16 @@ public function validateValueForProperty(PropertyReflector $property, mixed $val
     }
 
     /**
-     * Validates the specified `$value` against the specified set `$rules`.
+     * Validates the specified `$value` against the specified set of `$rules`. If a rule is a closure, it may return a string as a validation error.
+     *
+     * @param Rule|array<Rule|(Closure(mixed $value):string|false)>|(Closure(mixed $value):string|false) $rules
+     * @return Rule[]
      */
     public function validateValue(mixed $value, Closure|Rule|array $rules): array
     {
         $failingRules = [];
 
-        foreach (arr($rules) as $rule) {
+        foreach (Arr\wrap($rules) as $rule) {
             if (! $rule) {
                 continue;
             }
@@ -149,7 +177,9 @@ public function validateValue(mixed $value, Closure|Rule|array $rules): array
      * If `$rules` doesn't contain a key for a value, it will not be validated.
      *
      * @param array<string,mixed> $values
-     * @param array<string,\Tempest\Validation\Rule> $rules
+     * @param array<string,Rule|(Closure(mixed $value):string|false)> $rules
+     *
+     * @return Rule[]
      */
     public function validateValues(iterable $values, array $rules): array
     {
@@ -168,6 +198,47 @@ public function validateValues(iterable $values, array $rules): array
         return $failingRules;
     }
 
+    /**
+     * Gets a localized validation error message for the specified rule.
+     */
+    public function getErrorMessage(Rule $rule, ?string $field = null): string
+    {
+        if ($rule instanceof HasErrorMessage) {
+            return $rule->getErrorMessage();
+        }
+
+        $ruleTranslationKey = str($rule::class)
+            ->classBasename()
+            ->snake()
+            ->replaceEvery([ // those are snake case issues that we manually fix for consistency
+                'i_pv6' => 'ipv6',
+                'i_pv4' => 'ipv4',
+                'reg_ex' => 'regex',
+            ])
+            ->toString();
+
+        $variables = [
+            'field' => $this->getFieldName($ruleTranslationKey, $field),
+        ];
+
+        if ($rule instanceof HasTranslationVariables) {
+            $variables = [...$variables, ...$rule->getTranslationVariables()];
+        }
+
+        return $this->translator->translate("validation_error.{$ruleTranslationKey}", ...$variables);
+    }
+
+    private function getFieldName(string $key, ?string $field = null): string
+    {
+        $translatedField = $this->translator->translate("validation_field.{$key}");
+
+        if ($translatedField === "validation_field.{$key}") {
+            return $field ?? 'Value';
+        }
+
+        return $field ?? $translatedField;
+    }
+
     private function convertToRule(Rule|Closure $rule, mixed $value): Rule
     {
         if ($rule instanceof Rule) {
@@ -182,10 +253,10 @@ private function convertToRule(Rule|Closure $rule, mixed $value): Rule
             default => [true, ''],
         };
 
-        return new class($isValid, $message) implements Rule {
+        return new class($isValid, $message) implements Rule, HasErrorMessage {
             public function __construct(
                 private bool $isValid,
-                private string $message,
+                public string $message,
             ) {}
 
             public function isValid(mixed $value): bool
@@ -193,7 +264,7 @@ public function isValid(mixed $value): bool
                 return $this->isValid;
             }
 
-            public function message(): string
+            public function getErrorMessage(): string
             {
                 return $this->message;
             }
diff --git a/packages/validation/src/localization.en.yml b/packages/validation/src/localization.en.yml
new file mode 100644
index 000000000..5618bb97c
--- /dev/null
+++ b/packages/validation/src/localization.en.yml
@@ -0,0 +1,249 @@
+validation_field:
+  is_after_date: Date
+  is_before_date: Date
+  is_between: Number
+  is_between_dates: Date
+  is_divisible_by: Number
+  is_email: Email
+  is_even_number: Number
+  is_odd_number: Number
+  is_multiple_of: Number
+  is_password: Password
+validation_error:
+  is_after_date: |
+    .input {$field :string}
+    .input {$inclusive :boolean}
+    .input {$date :datetime date_style=long time_style=none}
+    .match $inclusive
+      true {{{$field} must be after or equal to {$date}}}
+      false {{{$field} must be after {$date}}}
+  is_alpha: |
+    .input {$field :string}
+    {$field} must contain only alphabetic characters
+  is_alpha_numeric: |
+    .input {$field :string}
+    {$field} must contain only alphanumeric characters
+  is_array_list: |
+    .input {$field :string}
+    {$field} must be a list
+  is_before_date: |
+    .input {$field :string}
+    .input {$inclusive :boolean}
+    .input {$date :datetime date_style=long time_style=none}
+    .match $inclusive
+      true {{{$field} must be a date before or equal to {$date}}}
+      false {{{$field} must be a date before {$date}}}
+  is_between: |
+    .input {$field :string}
+    .input {$min :number}
+    .input {$max :number}
+    {$field} must be between {$min} and {$max}
+  is_between_dates: |
+    .input {$field :string}
+    .input {$first :datetime date_style=long time_style=none}
+    .input {$second :datetime date_style=long time_style=none}
+    .input {$inclusive :boolean}
+    .match $inclusive
+      true {{{$field} must be a date between {$first} and {$second}, included}}
+      false {{{$field} must be a date between {$first} and {$second}}}
+  has_count: |
+    .input {$field :string}
+    .input {$min :number default=null}
+    .input {$max :number default=null}
+    .local $has_min = {$min :boolean}
+    .local $has_max = {$max :boolean}
+    .match $has_min $has_max
+      true true {{{$field} must have between {$min} and {$max} items}}
+      true false {{{$field} must have at least {$min} items}}
+      false true {{{$field} must have at most {$max} items}}
+  has_date_time_format: |
+    .input {$field :string}
+    .input {$format :string}
+    {$field} must use the format {$format}
+  is_divisible_by: |
+    .input {$field :string}
+    .input {$divisor :number}
+    {$field} must be divisible by {$divisor}
+  does_not_end_with: |
+    .input {$field :string}
+    .input {$needle :string}
+    {$field} must not end with "{$needle}"
+  does_not_start_with: |
+    .input {$field :string}
+    .input {$needle :string}
+    {$field} must not start with "{$needle}"
+  is_email: |
+    .input {$field :string}
+    {$field} must be a valid email address
+  ends_with: |
+    .input {$field :string}
+    .input {$needle :string}
+    {$field} must end with "{$needle}"
+  is_even_number: |
+    .input {$field :string}
+    {$field} must be even
+  is_hex_color: |
+    .input {$field :string}
+    {$field} must be a hexadecimal color
+  is_in: |
+    .input {$field :string}
+    .input {$values :string final_glue=| or |}
+    {$field} must be {$values}
+  is_ip: |
+    .input {$field :string}
+    .input {$allow_private_range :boolean}
+    .input {$allow_reserved_range :boolean}
+    .match $allow_private_range $allow_reserved_range
+      true true {{{$field} must be a valid IP address}}
+      true false {{{$field} must be a valid IP address, not in a reserved range}}
+      false true {{{$field} must be a valid IP address, not in a private range}}
+      false false {{{$field} must be a valid IP address, not in a private or reserved range}}
+  is_ipv4: |
+    .input {$field :string}
+    .input {$allow_private_range :boolean}
+    .input {$allow_reserved_range :boolean}
+    .match $allow_private_range $allow_reserved_range
+      true true {{{$field} must be a valid IPv4 address}}
+      true false {{{$field} must be a valid IPv4 address, not in a reserved range}}
+      false true {{{$field} must be a valid IPv4 address, not in a private range}}
+      false false {{{$field} must be a valid IPv4 address, not in a private or reserved range}}
+  is_ipv6: |
+    .input {$field :string}
+    .input {$allow_private_range :boolean}
+    .input {$allow_reserved_range :boolean}
+    .match $allow_private_range $allow_reserved_range
+      true true {{{$field} must be a valid IPv6 address}}
+      true false {{{$field} must be a valid IPv6 address, not in a reserved range}}
+      false true {{{$field} must be a valid IPv6 address, not in a private range}}
+      false false {{{$field} must be a valid IPv6 address, not in a private or reserved range}}
+  is_boolean: |
+    .input {$field :string}
+    .input {$or_null :boolean}
+    .match $or_null
+      true {{{$field} must be a boolean if specified}}
+      false {{{$field} must be a boolean}}
+  is_enum: |
+    .input {$field :string}
+    .input {$values :string final_glue=| or |}
+    {$field} must be {$values}
+  is_float: |
+    .input {$field :string}
+    .input {$or_null :boolean}
+    .match $or_null
+      true {{{$field} must be a floating point number if specified}}
+      false {{{$field} must be a floating point number}}
+  is_integer: |
+    .input {$field :string}
+    .input {$or_null :boolean}
+    .match $or_null
+      true {{{$field} must be a number if specified}}
+      false {{{$field} must be a number}}
+  is_string: |
+    .input {$field :string}
+    .input {$or_null :boolean}
+    .match $or_null
+      true {{{$field} must be a string or be empty}}
+      false {{{$field} must be a string}}
+  is_json_string: |
+    .input {$field :string}
+    {$field} must be a valid JSON string
+  has_length: |
+    .input {$field :string}
+    .input {$min :number default=null}
+    .input {$max :number default=null}
+    .local $has_min = {$min :boolean}
+    .local $has_max = {$max :boolean}
+    .match $has_min $has_max
+      true true {{{$field} must be between {$min} and {$max}}}
+      true false {{{$field} must be at least {$min}}}
+      false true {{{$field} must be at most {$max}}}
+  is_lowercase: |
+    .input {$field :string}
+    {$field} must be a lowercase string
+  is_mac_address: |
+    .input {$field :string}
+    {$field} must be a valid MAC address
+  is_multiple_of: |
+    .input {$field :string}
+    .input {$divisor :number}
+    {$field} must be a multiple of {$divisor}
+  is_not_empty_string: |
+    .input {$field :string}
+    {$field} must not be empty
+  is_not_in: |
+    .input {$field :string}
+    .input {$values :string final_glue=| or |}
+    {$field} must not be {$values}
+  is_not_null: |
+    .input {$field :string}
+    {$field} must be specified
+  is_numeric: |
+    .input {$field :string}
+    {$field} must be numeric
+  is_odd_number: |
+    .input {$field :string}
+    {$field} must be odd
+  is_password: |
+    .input {$min :number}
+    .input {$mixed_case :boolean}
+    .input {$numbers :boolean}
+    .input {$letters :boolean}
+    .input {$symbols :boolean}
+    .match $mixed_case $numbers $letters $symbols
+      true true * true {{{$field} must contain at least {$min} characters, one uppercase and one lowercase letter, one number, and one symbol}}
+      true true * false {{{$field} must contain at least {$min} characters, one uppercase and one lowercase letter, and one number}}
+      true false * true {{{$field} must contain at least {$min} characters, one uppercase and one lowercase letter, and one symbol}}
+      true false * false {{{$field} must contain at least {$min} characters, one uppercase and one lowercase letter}}
+      false true true true {{{$field} must contain at least {$min} characters, one number, one letter and one symbol}}
+      false true true false {{{$field} must contain at least {$min} characters, one number and one letter}}
+      false false true true {{{$field} must contain at least {$min} characters, one letter and one symbol}}
+      false true false true {{{$field} must contain at least {$min} characters, one number and one symbol}}
+      false true false false {{{$field} must contain at least {$min} characters and one number}}
+      false false true false {{{$field} must contain at least {$min} characters and one letter}}
+      false false false true {{{$field} must contain at least {$min} characters and one symbol}}
+      * * * * {{{$field} must contain at least {$min} characters}}
+  is_phone_number: |
+    .input {$field :string}
+    {$field} must be a phone number
+  matches_regex: |
+    .input {$field :string}
+    .input {$pattern :string}
+    {$field} must match the pattern {$pattern}
+  is_falsy: |
+    .input {$field :string}
+    {$field} must be false
+  is_truthy: |
+    .input {$field :string}
+    {$field} must be true
+  starts_with: |
+    .input {$field :string}
+    .input {$needle :string}
+    {$field} must start with {$needle}
+  is_time: |
+    .input {$field :string}
+    .input {$twenty_four_hour :boolean}
+    .match $twenty_four_hour
+      true {{{$field} must be a valid time in 24-hour format}}
+      false {{{$field} must be a valid time in 12-hour format}}
+  is_unix_timestamp: |
+    .input {$field :string}
+    {$field} must be a valid timestamp
+  is_timezone: |
+    .input {$field :string}
+    {$field} must be a valid timezone
+  is_ulid: |
+    .input {$field :string}
+    {$field} must be a lexicographically sortable identifier
+  is_uppercase: |
+    .input {$field :string}
+    {$field} must be an uppercase string
+  is_url: |
+    .input {$field :string}
+    .input {$protocols :string final_glue=| or |}
+    .local $has_protocols = {$protocols :boolean}
+    .match $has_protocols
+      false {{{$field} must be a valid URL}}
+      true {{{$field} must be a URL using {$protocols}}}
+  is_uuid: |
+    .input {$field :string}
+    {$field} must be a universally unique identifier
diff --git a/packages/validation/tests/Fixtures/ObjectToBeValidated.php b/packages/validation/tests/Fixtures/ObjectToBeValidated.php
index effd6ab5f..0b3e6a891 100644
--- a/packages/validation/tests/Fixtures/ObjectToBeValidated.php
+++ b/packages/validation/tests/Fixtures/ObjectToBeValidated.php
@@ -4,12 +4,12 @@
 
 namespace Tempest\Validation\Tests\Fixtures;
 
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class ObjectToBeValidated
 {
     public function __construct(
-        #[Length(min: 2, max: 3)]
+        #[HasLength(min: 2, max: 3)]
         public string $name,
     ) {}
 }
diff --git a/packages/validation/tests/Fixtures/ValidateObjectB.php b/packages/validation/tests/Fixtures/ValidateObjectB.php
index b683ce79f..dee1e3c6a 100644
--- a/packages/validation/tests/Fixtures/ValidateObjectB.php
+++ b/packages/validation/tests/Fixtures/ValidateObjectB.php
@@ -4,13 +4,13 @@
 
 namespace Tempest\Validation\Tests\Fixtures;
 
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class ValidateObjectB
 {
     public ValidateObjectC $c;
 
-    #[Length(min: 2)]
+    #[HasLength(min: 2)]
     public string $name;
 
     public int $age;
diff --git a/packages/validation/tests/Fixtures/ValidateObjectC.php b/packages/validation/tests/Fixtures/ValidateObjectC.php
index edd27db10..be3fa4bae 100644
--- a/packages/validation/tests/Fixtures/ValidateObjectC.php
+++ b/packages/validation/tests/Fixtures/ValidateObjectC.php
@@ -4,14 +4,14 @@
 
 namespace Tempest\Validation\Tests\Fixtures;
 
-use Tempest\Validation\Rules\Email;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
+use Tempest\Validation\Rules\IsEmail;
 
 final class ValidateObjectC
 {
-    #[Length(min: 2)]
+    #[HasLength(min: 2)]
     public string $name;
 
-    #[Email]
+    #[IsEmail]
     public string $email;
 }
diff --git a/packages/validation/tests/NullTranslator.php b/packages/validation/tests/NullTranslator.php
new file mode 100644
index 000000000..27e4fabd8
--- /dev/null
+++ b/packages/validation/tests/NullTranslator.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Tempest\Validation\Tests;
+
+use Tempest\Intl\Locale;
+use Tempest\Intl\Translator;
+
+final class NullTranslator implements Translator
+{
+    public function translate(string $key, mixed ...$arguments): string
+    {
+        return $key;
+    }
+
+    public function translateForLocale(Locale $locale, string $key, mixed ...$arguments): string
+    {
+        return $key;
+    }
+}
diff --git a/packages/validation/tests/Rules/AfterDateTest.php b/packages/validation/tests/Rules/AfterDateTest.php
index 62017bc77..4402c1803 100644
--- a/packages/validation/tests/Rules/AfterDateTest.php
+++ b/packages/validation/tests/Rules/AfterDateTest.php
@@ -9,7 +9,7 @@
 use PHPUnit\Framework\TestCase;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\Timezone;
-use Tempest\Validation\Rules\AfterDate;
+use Tempest\Validation\Rules\IsAfterDate;
 
 /**
  * @internal
@@ -19,7 +19,7 @@ final class AfterDateTest extends TestCase
     public function test_exclusive(): void
     {
         $now = DateTime::now();
-        $rule = new AfterDate($now);
+        $rule = new IsAfterDate($now);
 
         $this->assertFalse($rule->isValid($now));
         $this->assertFalse($rule->isValid($now->minusSecond()));
@@ -29,7 +29,7 @@ public function test_exclusive(): void
     public function test_inclusive(): void
     {
         $now = DateTime::now();
-        $rule = new AfterDate($now, inclusive: true);
+        $rule = new IsAfterDate($now, inclusive: true);
 
         $this->assertTrue($rule->isValid($now));
         $this->assertFalse($rule->isValid($now->minusSecond()));
@@ -39,9 +39,7 @@ public function test_inclusive(): void
     public function test_native_exclusive(): void
     {
         $date = new DateTimeImmutable();
-        $rule = new AfterDate($date);
-
-        $this->assertSame('Value must be a date after ' . $this->formatNativeDateTime($date), $rule->message());
+        $rule = new IsAfterDate($date);
 
         $this->assertTrue($rule->isValid($date->modify('+1 minute')));
         $this->assertFalse($rule->isValid($date->modify('-1 second')));
@@ -51,9 +49,7 @@ public function test_native_exclusive(): void
     public function test_native_inclusive(): void
     {
         $date = new DateTimeImmutable();
-        $rule = new AfterDate($date, inclusive: true);
-
-        $this->assertSame('Value must be a date after or equal to ' . $this->formatNativeDateTime($date), $rule->message());
+        $rule = new IsAfterDate($date, inclusive: true);
 
         $this->assertTrue($rule->isValid($date->modify('+1 minute')));
         $this->assertFalse($rule->isValid($date->modify('-1 second')));
@@ -63,7 +59,7 @@ public function test_native_inclusive(): void
     public function test_timezone(): void
     {
         $now = DateTime::now(timezone: Timezone::EUROPE_PARIS);
-        $rule = new AfterDate($now->convertToTimezone(Timezone::AMERICA_NEW_YORK), inclusive: false);
+        $rule = new IsAfterDate($now->convertToTimezone(Timezone::AMERICA_NEW_YORK), inclusive: false);
 
         // should still work even with different timezones
         $this->assertFalse($rule->isValid($now));
@@ -74,7 +70,7 @@ public function test_timezone(): void
     public function test_native_timezone(): void
     {
         $date = new DateTimeImmutable('now', new DateTimeZone('America/New_York'));
-        $rule = new AfterDate($date, inclusive: false);
+        $rule = new IsAfterDate($date, inclusive: false);
         $utcDate = new DateTimeImmutable();
 
         // should still work even with different timezones
@@ -82,9 +78,4 @@ public function test_native_timezone(): void
         $this->assertTrue($rule->isValid($utcDate->modify('+1 minute')));
         $this->assertFalse($rule->isValid($utcDate->modify('-1 minute')));
     }
-
-    private function formatNativeDateTime(DateTimeImmutable $dateTime): string
-    {
-        return DateTime::parse($dateTime)->format();
-    }
 }
diff --git a/packages/validation/tests/Rules/CountTest.php b/packages/validation/tests/Rules/CountTest.php
deleted file mode 100644
index 750f0034b..000000000
--- a/packages/validation/tests/Rules/CountTest.php
+++ /dev/null
@@ -1,86 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Tests\Rules;
-
-use InvalidArgumentException;
-use PHPUnit\Framework\Attributes\DataProvider;
-use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Count;
-
-/**
- * @internal
- */
-final class CountTest extends TestCase
-{
-    #[DataProvider('provide_count_cases')]
-    public function test_count(Count $rule, array $stringToTest, bool $expected): void
-    {
-        $this->assertEquals($expected, $rule->isValid($stringToTest));
-    }
-
-    #[DataProvider('provide_returns_the_proper_message_based_on_min_and_max_arguments_cases')]
-    public function test_returns_the_proper_message_based_on_min_and_max_arguments(
-        Count $rule,
-        string $expectedMessage,
-    ): void {
-        $this->assertEquals($expectedMessage, $rule->message());
-    }
-
-    public function test_throws_an_exception_if_neither_min_or_max_is_supplied(): void
-    {
-        $this->expectException(InvalidArgumentException::class);
-
-        new Count();
-    }
-
-    public static function provide_returns_the_proper_message_based_on_min_and_max_arguments_cases(): iterable
-    {
-        return [
-            'Should provide correct message when both min and max limits are defined (1, 5)' => [
-                new Count(min: 1, max: 5),
-                'Array should contain between 1 and 5 items',
-            ],
-            'Should provide correct message when only min limit is defined (1)' => [
-                new Count(min: 1),
-                'Array should contain no less than 1 items',
-            ],
-            'Should provide correct message when only max limit is defined (5)' => [
-                new Count(max: 5),
-                'Array should contain no more than 5 items',
-            ],
-        ];
-    }
-
-    public static function provide_count_cases(): iterable
-    {
-        return [
-            'Should invalidate when array length is less than the minimum limit (1)' => [
-                new Count(min: 1, max: 5),
-                [],
-                false,
-            ],
-            'Should validate when array length is exactly the minimum limit (1)' => [
-                new Count(min: 1, max: 5),
-                [1],
-                true,
-            ],
-            'Should validate when array length is between the minimum (1) and maximum (5) limits' => [
-                new Count(min: 1, max: 5),
-                [1, 2, 3],
-                true,
-            ],
-            'Should validate when array length is exactly at the maximum limit (5)' => [
-                new Count(min: 1, max: 5),
-                [1, 2, 3, 4, 5],
-                true,
-            ],
-            'Should invalidate when array length is greater than the maximum limit (5)' => [
-                new Count(min: 1, max: 5),
-                [1, 2, 3, 4, 5, 6],
-                false,
-            ],
-        ];
-    }
-}
diff --git a/packages/validation/tests/Rules/DivisibleByTest.php b/packages/validation/tests/Rules/DivisibleByTest.php
index 0b2ac46f4..b57abe09d 100644
--- a/packages/validation/tests/Rules/DivisibleByTest.php
+++ b/packages/validation/tests/Rules/DivisibleByTest.php
@@ -5,7 +5,7 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\DivisibleBy;
+use Tempest\Validation\Rules\IsDivisibleBy;
 
 /**
  * @internal
@@ -14,7 +14,7 @@ final class DivisibleByTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new DivisibleBy(5);
+        $rule = new IsDivisibleBy(5);
 
         $this->assertTrue($rule->isValid(10));
         $this->assertTrue($rule->isValid(5));
@@ -23,7 +23,5 @@ public function test_it_works(): void
         $this->assertFalse($rule->isValid(3));
         $this->assertFalse($rule->isValid(4));
         $this->assertFalse($rule->isValid(6));
-
-        $this->assertSame('Value should be divisible by 5', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/DoesNotEndWithTest.php b/packages/validation/tests/Rules/DoesNotEndWithTest.php
index 9f9a26a71..90a047d79 100644
--- a/packages/validation/tests/Rules/DoesNotEndWithTest.php
+++ b/packages/validation/tests/Rules/DoesNotEndWithTest.php
@@ -18,8 +18,6 @@ public function test_rule(string $needle, string $stringToTest, bool $expected):
     {
         $rule = new DoesNotEndWith($needle);
 
-        $this->assertSame('Value should not end with ' . $needle, $rule->message());
-
         $this->assertEquals($expected, $rule->isValid($stringToTest));
     }
 
diff --git a/packages/validation/tests/Rules/DoesNotStartWithTest.php b/packages/validation/tests/Rules/DoesNotStartWithTest.php
index 381968ac9..458fae477 100644
--- a/packages/validation/tests/Rules/DoesNotStartWithTest.php
+++ b/packages/validation/tests/Rules/DoesNotStartWithTest.php
@@ -18,8 +18,6 @@ public function test_rule(string $needle, string $stringToTest, bool $expected):
     {
         $rule = new DoesNotStartWith($needle);
 
-        $this->assertSame('Value should not start with ' . $needle, $rule->message());
-
         $this->assertEquals($expected, $rule->isValid($stringToTest));
     }
 
diff --git a/packages/validation/tests/Rules/EndsWithTest.php b/packages/validation/tests/Rules/EndsWithTest.php
index fff39df14..b8553a4b9 100644
--- a/packages/validation/tests/Rules/EndsWithTest.php
+++ b/packages/validation/tests/Rules/EndsWithTest.php
@@ -16,8 +16,6 @@ public function test_ends_with(): void
     {
         $rule = new EndsWith(needle: 'ab');
 
-        $this->assertSame('Value should end with ab', $rule->message());
-
         $this->assertTrue($rule->isValid('ab'));
         $this->assertTrue($rule->isValid('cab'));
         $this->assertFalse($rule->isValid('b'));
diff --git a/packages/validation/tests/Rules/HasCountTest.php b/packages/validation/tests/Rules/HasCountTest.php
new file mode 100644
index 000000000..031052012
--- /dev/null
+++ b/packages/validation/tests/Rules/HasCountTest.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Tests\Rules;
+
+use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use Tempest\Validation\Rules\HasCount;
+
+/**
+ * @internal
+ */
+final class HasCountTest extends TestCase
+{
+    #[DataProvider('provide_count_cases')]
+    public function test_count(HasCount $rule, array $stringToTest, bool $expected): void
+    {
+        $this->assertEquals($expected, $rule->isValid($stringToTest));
+    }
+
+    public function test_throws_an_exception_if_neither_min_or_max_is_supplied(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        new HasCount();
+    }
+
+    public static function provide_count_cases(): iterable
+    {
+        return [
+            'Should invalidate when array length is less than the minimum limit (1)' => [
+                new HasCount(min: 1, max: 5),
+                [],
+                false,
+            ],
+            'Should validate when array length is exactly the minimum limit (1)' => [
+                new HasCount(min: 1, max: 5),
+                [1],
+                true,
+            ],
+            'Should validate when array length is between the minimum (1) and maximum (5) limits' => [
+                new HasCount(min: 1, max: 5),
+                [1, 2, 3],
+                true,
+            ],
+            'Should validate when array length is exactly at the maximum limit (5)' => [
+                new HasCount(min: 1, max: 5),
+                [1, 2, 3, 4, 5],
+                true,
+            ],
+            'Should invalidate when array length is greater than the maximum limit (5)' => [
+                new HasCount(min: 1, max: 5),
+                [1, 2, 3, 4, 5, 6],
+                false,
+            ],
+        ];
+    }
+}
diff --git a/packages/validation/tests/Rules/DateTimeFormatTest.php b/packages/validation/tests/Rules/HasDateTimeFormatTest.php
similarity index 70%
rename from packages/validation/tests/Rules/DateTimeFormatTest.php
rename to packages/validation/tests/Rules/HasDateTimeFormatTest.php
index 2fccf5e9c..1bf670bef 100644
--- a/packages/validation/tests/Rules/DateTimeFormatTest.php
+++ b/packages/validation/tests/Rules/HasDateTimeFormatTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 /**
  * @internal
  */
-final class DateTimeFormatTest extends TestCase
+final class HasDateTimeFormatTest extends TestCase
 {
     public function test_datetime_format(): void
     {
-        $rule = new DateTimeFormat(format: 'yyyy-MM-dd HH:mm:ss');
+        $rule = new HasDateTimeFormat(format: 'yyyy-MM-dd HH:mm:ss');
 
         $this->assertFalse($rule->isValid(false));
         $this->assertFalse($rule->isValid(null));
@@ -27,22 +27,15 @@ public function test_datetime_format(): void
 
     public function test_datetime_format_with_different_format(): void
     {
-        $rule = new DateTimeFormat('dd/MM/yyyy');
+        $rule = new HasDateTimeFormat('dd/MM/yyyy');
 
         $this->assertFalse($rule->isValid('2024-02-19'));
         $this->assertTrue($rule->isValid('19/02/2024'));
     }
 
-    public function test_datetime_format_message(): void
-    {
-        $rule = new DateTimeFormat(format: 'yyyy-MM-dd HH:mm:ss');
-
-        $this->assertSame('Value should be a valid datetime in the format yyyy-MM-dd HH:mm:ss', $rule->message());
-    }
-
     public function test_datetime_native_format(): void
     {
-        $rule = new DateTimeFormat(format: 'Y-m-d H:i:s');
+        $rule = new HasDateTimeFormat(format: 'Y-m-d H:i:s');
 
         $this->assertFalse($rule->isValid(false));
         $this->assertFalse($rule->isValid(null));
diff --git a/packages/validation/tests/Rules/LengthTest.php b/packages/validation/tests/Rules/HasLengthTest.php
similarity index 62%
rename from packages/validation/tests/Rules/LengthTest.php
rename to packages/validation/tests/Rules/HasLengthTest.php
index 55da49916..11cc1ab3d 100644
--- a/packages/validation/tests/Rules/LengthTest.php
+++ b/packages/validation/tests/Rules/HasLengthTest.php
@@ -7,87 +7,61 @@
 use InvalidArgumentException;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 /**
  * @internal
  */
-final class LengthTest extends TestCase
+final class HasLengthTest extends TestCase
 {
     #[DataProvider('provide_length_cases')]
-    public function test_length(Length $rule, string $stringToTest, bool $expected): void
+    public function test_length(HasLength $rule, string $stringToTest, bool $expected): void
     {
         $this->assertEquals($expected, $rule->isValid($stringToTest));
     }
 
-    #[DataProvider('provide_returns_the_proper_message_based_on_min_and_max_arguments_cases')]
-    public function test_returns_the_proper_message_based_on_min_and_max_arguments(
-        Length $rule,
-        string $expectedMessage,
-    ): void {
-        $this->assertEquals($expectedMessage, $rule->message());
-    }
-
     public function test_throws_an_exception_if_neither_min_or_max_is_supplied(): void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        new Length();
-    }
-
-    public static function provide_returns_the_proper_message_based_on_min_and_max_arguments_cases(): iterable
-    {
-        return [
-            'Should provide correct message for string length validation with both minimum and maximum limits of 10 to 20' => [
-                new Length(min: 10, max: 20),
-                'Value should be between 10 and 20',
-            ],
-            'Should provide correct message for string length validation being no less than 10' => [
-                new Length(min: 10),
-                'Value should be no less than 10',
-            ],
-            'Should provide correct message for string length validation being no more than 10' => [
-                new Length(max: 10),
-                'Value should be no more than 10',
-            ],
-        ];
+        new HasLength();
     }
 
     public static function provide_length_cases(): iterable
     {
         return [
             'Should return true when string meets minimum length requirement of 10' => [
-                new Length(min: 10),
+                new HasLength(min: 10),
                 'aaaaaaaaaa',
                 true,
             ],
             'Should return true when string exceeds minimum length requirement of 10' => [
-                new Length(min: 10),
+                new HasLength(min: 10),
                 'aaaaaaaaaaa',
                 true,
             ],
             'Should return false when string does not meet minimum length requirement of 10' => [
-                new Length(min: 10),
+                new HasLength(min: 10),
                 'aaaaaaaaa',
                 false,
             ],
             'Should return true when string meets maximum length requirement of 5' => [
-                new Length(max: 5),
+                new HasLength(max: 5),
                 'aaaaa',
                 true,
             ],
             'Should return true when string is shorter than maximum length requirement of 5' => [
-                new Length(max: 5),
+                new HasLength(max: 5),
                 'aaaa',
                 true,
             ],
             'Should return false when string exceeds maximum length requirement of 5' => [
-                new Length(max: 5),
+                new HasLength(max: 5),
                 'aaaaaa',
                 false,
             ],
             'Should return true when string is within minimum and maximum length requirement of 2-5' => [
-                new Length(
+                new HasLength(
                     min: 2,
                     max: 5,
                 ),
@@ -95,7 +69,7 @@ public static function provide_length_cases(): iterable
                 true,
             ],
             'Should return true when string is within minimum and maximum length requirement of 2-5 but shorter' => [
-                new Length(
+                new HasLength(
                     min: 2,
                     max: 5,
                 ),
@@ -103,7 +77,7 @@ public static function provide_length_cases(): iterable
                 true,
             ],
             'Should return true when string meets minimum length requirement of 2 within 2-5 limit' => [
-                new Length(
+                new HasLength(
                     min: 2,
                     max: 5,
                 ),
@@ -111,7 +85,7 @@ public static function provide_length_cases(): iterable
                 true,
             ],
             'Should return false when string does not meet minimum length requirement of 2 within 2-5 limit' => [
-                new Length(
+                new HasLength(
                     min: 2,
                     max: 5,
                 ),
@@ -119,7 +93,7 @@ public static function provide_length_cases(): iterable
                 false,
             ],
             'Should return false when string exceeds maximum length requirement of 5 within 2-5 limit' => [
-                new Length(
+                new HasLength(
                     min: 2,
                     max: 5,
                 ),
diff --git a/packages/validation/tests/Rules/IPTest.php b/packages/validation/tests/Rules/IPTest.php
deleted file mode 100644
index 4ef6d81e4..000000000
--- a/packages/validation/tests/Rules/IPTest.php
+++ /dev/null
@@ -1,48 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Tests\Rules;
-
-use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\IP;
-
-/**
- * @internal
- */
-final class IPTest extends TestCase
-{
-    public function test_ip_address(): void
-    {
-        $rule = new IP();
-
-        $this->assertSame('Value should be a valid IP address', $rule->message());
-
-        $this->assertTrue($rule->isValid('192.168.0.1'));
-        $this->assertTrue($rule->isValid('10.0.0.1'));
-        $this->assertTrue($rule->isValid('172.16.0.1'));
-        $this->assertTrue($rule->isValid('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
-        $this->assertTrue($rule->isValid('2001:db8:85a3::8a2e:370:7334'));
-
-        $this->assertFalse($rule->isValid('256.0.0.1'));
-        $this->assertFalse($rule->isValid('300.168.0.1'));
-        $this->assertFalse($rule->isValid('192.168.0'));
-        $this->assertFalse($rule->isValid('192.168.0.1.2'));
-        $this->assertFalse($rule->isValid('192.168.0.1/24'));
-    }
-
-    public function test_messages(): void
-    {
-        $rule = new IP();
-        $this->assertSame('Value should be a valid IP address', $rule->message());
-
-        $rule = new IP(allowPrivateRange: false);
-        $this->assertSame('Value should be a valid IP address that is not in a private range', $rule->message());
-
-        $rule = new IP(allowReservedRange: false);
-        $this->assertSame('Value should be a valid IP address that is not in a reserved range', $rule->message());
-
-        $rule = new IP(allowPrivateRange: false, allowReservedRange: false);
-        $this->assertSame('Value should be a valid IP address that is not in a private range and not in a reserved range', $rule->message());
-    }
-}
diff --git a/packages/validation/tests/Rules/IPv4Test.php b/packages/validation/tests/Rules/IPv4Test.php
deleted file mode 100644
index a5c76bef1..000000000
--- a/packages/validation/tests/Rules/IPv4Test.php
+++ /dev/null
@@ -1,59 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Tests\Rules;
-
-use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\IPv4;
-
-/**
- * @internal
- */
-final class IPv4Test extends TestCase
-{
-    public function test_ipv4_address(): void
-    {
-        $rule = new IPv4();
-
-        $this->assertSame('Value should be a valid IPv4 address', $rule->message());
-
-        $this->assertTrue($rule->isValid('192.168.0.1'));
-        $this->assertTrue($rule->isValid('10.0.0.1'));
-        $this->assertTrue($rule->isValid('172.16.0.1'));
-
-        $this->assertFalse($rule->isValid('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
-        $this->assertFalse($rule->isValid('2001:db8:85a3::8a2e:370:7334'));
-    }
-
-    public function test_ip_address_without_private_range(): void
-    {
-        $rule = new IPv4(allowPrivateRange: false);
-
-        $this->assertFalse($rule->isValid('192.168.1.1'));
-        $this->assertTrue($rule->isValid('210.221.151.70'));
-    }
-
-    public function test_ip_address_without_reserved_range(): void
-    {
-        $rule = new IPv4(allowReservedRange: false);
-
-        $this->assertFalse($rule->isValid('169.254.0.0'));
-        $this->assertTrue($rule->isValid('172.16.1.1'));
-    }
-
-    public function test_messages(): void
-    {
-        $rule = new IPv4();
-        $this->assertSame('Value should be a valid IPv4 address', $rule->message());
-
-        $rule = new IPv4(allowPrivateRange: false);
-        $this->assertSame('Value should be a valid IPv4 address that is not in a private range', $rule->message());
-
-        $rule = new IPv4(allowReservedRange: false);
-        $this->assertSame('Value should be a valid IPv4 address that is not in a reserved range', $rule->message());
-
-        $rule = new IPv4(allowPrivateRange: false, allowReservedRange: false);
-        $this->assertSame('Value should be a valid IPv4 address that is not in a private range and not in a reserved range', $rule->message());
-    }
-}
diff --git a/packages/validation/tests/Rules/AlphaNumericTest.php b/packages/validation/tests/Rules/IsAlphaNumericTest.php
similarity index 67%
rename from packages/validation/tests/Rules/AlphaNumericTest.php
rename to packages/validation/tests/Rules/IsAlphaNumericTest.php
index f8a27dcf7..adea33329 100644
--- a/packages/validation/tests/Rules/AlphaNumericTest.php
+++ b/packages/validation/tests/Rules/IsAlphaNumericTest.php
@@ -5,18 +5,17 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\AlphaNumeric;
+use Tempest\Validation\Rules\IsAlphaNumeric;
 
 /**
  * @internal
  */
-final class AlphaNumericTest extends TestCase
+final class IsAlphaNumericTest extends TestCase
 {
     public function test_alphanumeric(): void
     {
-        $rule = new AlphaNumeric();
+        $rule = new IsAlphaNumeric();
 
-        $this->assertSame('Value should only contain alphanumeric characters', $rule->message());
         $this->assertFalse($rule->isValid('string_123'));
         $this->assertTrue($rule->isValid('string123'));
         $this->assertTrue($rule->isValid('STRING123'));
diff --git a/packages/validation/tests/Rules/AlphaTest.php b/packages/validation/tests/Rules/IsAlphaTest.php
similarity index 69%
rename from packages/validation/tests/Rules/AlphaTest.php
rename to packages/validation/tests/Rules/IsAlphaTest.php
index 12aa5dd2a..121658c8a 100644
--- a/packages/validation/tests/Rules/AlphaTest.php
+++ b/packages/validation/tests/Rules/IsAlphaTest.php
@@ -5,18 +5,17 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Alpha;
+use Tempest\Validation\Rules\IsAlpha;
 
 /**
  * @internal
  */
-final class AlphaTest extends TestCase
+final class IsAlphaTest extends TestCase
 {
     public function test_alpha(): void
     {
-        $rule = new Alpha();
+        $rule = new IsAlpha();
 
-        $this->assertSame('Value should only contain alphabetic characters', $rule->message());
         $this->assertFalse($rule->isValid('string123'));
         $this->assertTrue($rule->isValid('string'));
         $this->assertTrue($rule->isValid('STRING'));
diff --git a/packages/validation/tests/Rules/ArrayListTest.php b/packages/validation/tests/Rules/IsArrayListTest.php
similarity index 70%
rename from packages/validation/tests/Rules/ArrayListTest.php
rename to packages/validation/tests/Rules/IsArrayListTest.php
index 490745142..e2d1f6bae 100644
--- a/packages/validation/tests/Rules/ArrayListTest.php
+++ b/packages/validation/tests/Rules/IsArrayListTest.php
@@ -5,21 +5,20 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\ArrayList;
+use Tempest\Validation\Rules\IsArrayList;
 
 /**
  * @internal
  */
-final class ArrayListTest extends TestCase
+final class IsArrayListTest extends TestCase
 {
     public function test_array_list(): void
     {
-        $rule = new ArrayList();
+        $rule = new IsArrayList();
 
         $this->assertFalse($rule->isValid(['foo' => 'bar']));
         $this->assertTrue($rule->isValid([]));
         $this->assertTrue($rule->isValid(['a', 'b', 'c']));
         $this->assertFalse($rule->isValid([0 => 'a', 1 => 'b', 3 => 'c']));
-        $this->assertSame('Value must be a list', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/BeforeDateTest.php b/packages/validation/tests/Rules/IsBeforeDateTest.php
similarity index 72%
rename from packages/validation/tests/Rules/BeforeDateTest.php
rename to packages/validation/tests/Rules/IsBeforeDateTest.php
index 657face9e..7042d867a 100644
--- a/packages/validation/tests/Rules/BeforeDateTest.php
+++ b/packages/validation/tests/Rules/IsBeforeDateTest.php
@@ -9,17 +9,17 @@
 use PHPUnit\Framework\TestCase;
 use Tempest\DateTime\DateTime;
 use Tempest\DateTime\Timezone;
-use Tempest\Validation\Rules\BeforeDate;
+use Tempest\Validation\Rules\IsBeforeDate;
 
 /**
  * @internal
  */
-final class BeforeDateTest extends TestCase
+final class IsBeforeDateTest extends TestCase
 {
     public function test_exclusive(): void
     {
         $now = DateTime::now();
-        $rule = new BeforeDate($now);
+        $rule = new IsBeforeDate($now);
 
         $this->assertFalse($rule->isValid($now));
         $this->assertTrue($rule->isValid($now->minusSecond()));
@@ -29,7 +29,7 @@ public function test_exclusive(): void
     public function test_inclusive(): void
     {
         $now = DateTime::now();
-        $rule = new BeforeDate($now, inclusive: true);
+        $rule = new IsBeforeDate($now, inclusive: true);
 
         $this->assertTrue($rule->isValid($now));
         $this->assertTrue($rule->isValid($now->minusSecond()));
@@ -39,9 +39,7 @@ public function test_inclusive(): void
     public function test_native_exclusive(): void
     {
         $date = new DateTimeImmutable();
-        $rule = new BeforeDate($date);
-
-        $this->assertSame('Value must be a date before ' . $this->formatNativeDateTime($date), $rule->message());
+        $rule = new IsBeforeDate($date);
 
         $this->assertFalse($rule->isValid($date->modify('+1 minute')));
         $this->assertTrue($rule->isValid($date->modify('-1 second')));
@@ -51,9 +49,7 @@ public function test_native_exclusive(): void
     public function test_native_inclusive(): void
     {
         $date = new DateTimeImmutable();
-        $rule = new BeforeDate($date, inclusive: true);
-
-        $this->assertSame('Value must be a date before or equal to ' . $this->formatNativeDateTime($date), $rule->message());
+        $rule = new IsBeforeDate($date, inclusive: true);
 
         $this->assertFalse($rule->isValid($date->modify('+1 minute')));
         $this->assertTrue($rule->isValid($date->modify('-1 second')));
@@ -63,7 +59,7 @@ public function test_native_inclusive(): void
     public function test_timezone(): void
     {
         $now = DateTime::now(timezone: Timezone::EUROPE_PARIS);
-        $rule = new BeforeDate($now->convertToTimezone(Timezone::AMERICA_NEW_YORK), inclusive: false);
+        $rule = new IsBeforeDate($now->convertToTimezone(Timezone::AMERICA_NEW_YORK), inclusive: false);
 
         // should still work even with different timezones
         $this->assertFalse($rule->isValid($now));
@@ -74,7 +70,7 @@ public function test_timezone(): void
     public function test_native_timezone(): void
     {
         $date = new DateTimeImmutable('now', new DateTimeZone('America/New_York'));
-        $rule = new BeforeDate($date, inclusive: false);
+        $rule = new IsBeforeDate($date, inclusive: false);
         $utcDate = new DateTimeImmutable();
 
         // should still work even with different timezones
@@ -82,9 +78,4 @@ public function test_native_timezone(): void
         $this->assertFalse($rule->isValid($utcDate->modify('+1 minute')));
         $this->assertTrue($rule->isValid($utcDate->modify('-1 minute')));
     }
-
-    private function formatNativeDateTime(DateTimeImmutable $dateTime): string
-    {
-        return DateTime::parse($dateTime)->format();
-    }
 }
diff --git a/packages/validation/tests/Rules/BetweenDatesTest.php b/packages/validation/tests/Rules/IsBetweenDatesTest.php
similarity index 86%
rename from packages/validation/tests/Rules/BetweenDatesTest.php
rename to packages/validation/tests/Rules/IsBetweenDatesTest.php
index 401440a2d..e96972b82 100644
--- a/packages/validation/tests/Rules/BetweenDatesTest.php
+++ b/packages/validation/tests/Rules/IsBetweenDatesTest.php
@@ -6,12 +6,12 @@
 
 use PHPUnit\Framework\TestCase;
 use Tempest\DateTime\DateTime;
-use Tempest\Validation\Rules\BetweenDates;
+use Tempest\Validation\Rules\IsBetweenDates;
 
 /**
  * @internal
  */
-final class BetweenDatesTest extends TestCase
+final class IsBetweenDatesTest extends TestCase
 {
     public function test_exclusive(): void
     {
@@ -19,7 +19,7 @@ public function test_exclusive(): void
         $first = $now->minusMinute();
         $second = $now->plusMinute();
 
-        $rule = new BetweenDates($first, $second);
+        $rule = new IsBetweenDates($first, $second);
 
         $this->assertTrue($rule->isValid($now));
         $this->assertTrue($rule->isValid($now->minusSeconds(59)));
@@ -38,7 +38,7 @@ public function test_inclusive(): void
         $first = $now->minusMinute();
         $second = $now->plusMinute();
 
-        $rule = new BetweenDates($first, $second, inclusive: true);
+        $rule = new IsBetweenDates($first, $second, inclusive: true);
 
         $this->assertTrue($rule->isValid($now));
         $this->assertTrue($rule->isValid($now->minusSeconds(59)));
diff --git a/packages/validation/tests/Rules/BetweenTest.php b/packages/validation/tests/Rules/IsBetweenTest.php
similarity index 67%
rename from packages/validation/tests/Rules/BetweenTest.php
rename to packages/validation/tests/Rules/IsBetweenTest.php
index 5da3b45a7..dcdc6d6ca 100644
--- a/packages/validation/tests/Rules/BetweenTest.php
+++ b/packages/validation/tests/Rules/IsBetweenTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Between;
+use Tempest\Validation\Rules\IsBetween;
 
 /**
  * @internal
  */
-final class BetweenTest extends TestCase
+final class IsBetweenTest extends TestCase
 {
     public function test_between(): void
     {
-        $rule = new Between(min: 0, max: 10);
-
-        $this->assertSame('Value should be between 0 and 10', $rule->message());
+        $rule = new IsBetween(min: 0, max: 10);
 
         $this->assertTrue($rule->isValid(0));
         $this->assertTrue($rule->isValid(10));
diff --git a/packages/validation/tests/Rules/IsBooleanTest.php b/packages/validation/tests/Rules/IsBooleanTest.php
index 87cc9b380..1d5d2eae2 100644
--- a/packages/validation/tests/Rules/IsBooleanTest.php
+++ b/packages/validation/tests/Rules/IsBooleanTest.php
@@ -24,15 +24,14 @@ public function test_boolean(): void
         $this->assertTrue($rule->isValid('false'));
         $this->assertTrue($rule->isValid(0));
         $this->assertTrue($rule->isValid('0'));
+        $this->assertTrue($rule->isValid('yes'));
+        $this->assertTrue($rule->isValid('no'));
+        $this->assertTrue($rule->isValid('enabled'));
+        $this->assertTrue($rule->isValid('disabled'));
+        $this->assertTrue($rule->isValid('off'));
+        $this->assertTrue($rule->isValid('on'));
         $this->assertFalse($rule->isValid(5));
         $this->assertFalse($rule->isValid(2.5));
         $this->assertFalse($rule->isValid('string'));
     }
-
-    public function test_boolean_message(): void
-    {
-        $rule = new IsBoolean();
-
-        $this->assertSame('Value should represent a boolean value', $rule->message());
-    }
 }
diff --git a/packages/validation/tests/Rules/EmailTest.php b/packages/validation/tests/Rules/IsEmailTest.php
similarity index 63%
rename from packages/validation/tests/Rules/EmailTest.php
rename to packages/validation/tests/Rules/IsEmailTest.php
index 4a48c4502..604bdf648 100644
--- a/packages/validation/tests/Rules/EmailTest.php
+++ b/packages/validation/tests/Rules/IsEmailTest.php
@@ -5,18 +5,17 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Email;
+use Tempest\Validation\Rules\IsEmail;
 
 /**
  * @internal
  */
-final class EmailTest extends TestCase
+final class IsEmailTest extends TestCase
 {
     public function test_email(): void
     {
-        $rule = new Email();
+        $rule = new IsEmail();
 
-        $this->assertSame('Value should be a valid email address', $rule->message());
         $this->assertFalse($rule->isValid('this is not an email'));
         $this->assertTrue($rule->isValid('jim.halpert@dundermifflinpaper.biz'));
     }
diff --git a/packages/validation/tests/Rules/EnumTest.php b/packages/validation/tests/Rules/IsEnumTest.php
similarity index 79%
rename from packages/validation/tests/Rules/EnumTest.php
rename to packages/validation/tests/Rules/IsEnumTest.php
index 2952d3e16..95dafe214 100644
--- a/packages/validation/tests/Rules/EnumTest.php
+++ b/packages/validation/tests/Rules/IsEnumTest.php
@@ -13,20 +13,12 @@
 /**
  * @internal
  */
-final class EnumTest extends TestCase
+final class IsEnumTest extends TestCase
 {
     public function test_validating_enums(): void
     {
         $rule = new IsEnum(SomeEnum::class);
 
-        $this->assertSame(
-            sprintf(
-                'The value must be a valid enumeration [%s] case',
-                SomeEnum::class,
-            ),
-            $rule->message(),
-        );
-
         $this->assertFalse($rule->isValid('NOPE_NOT_HERE'));
         $this->assertFalse($rule->isValid('NOPE_NOT_HERE_EITHER'));
         $this->assertTrue($rule->isValid('VALUE_1'));
@@ -37,14 +29,6 @@ public function test_validating_backed_enums(): void
     {
         $rule = new IsEnum(SomeBackedEnum::class);
 
-        $this->assertSame(
-            sprintf(
-                'The value must be a valid enumeration [%s] case',
-                SomeBackedEnum::class,
-            ),
-            $rule->message(),
-        );
-
         $this->assertFalse($rule->isValid('three'));
         $this->assertFalse($rule->isValid('four'));
         $this->assertTrue($rule->isValid('one'));
@@ -53,12 +37,7 @@ public function test_validating_backed_enums(): void
 
     public function test_enum_has_to_exist(): void
     {
-        $this->expectExceptionObject(new UnexpectedValueException(
-            sprintf(
-                'The enum parameter must be a valid enum. Was given [%s].',
-                'Bob',
-            ),
-        ));
+        $this->expectExceptionObject(new UnexpectedValueException(sprintf('The enum parameter must be a valid enum. Was given [%s].', 'Bob')));
 
         new IsEnum('Bob');
     }
diff --git a/packages/validation/tests/Rules/EvenRuleTest.php b/packages/validation/tests/Rules/IsEvenNumberTest.php
similarity index 69%
rename from packages/validation/tests/Rules/EvenRuleTest.php
rename to packages/validation/tests/Rules/IsEvenNumberTest.php
index 6dbbc6aac..65a4cf884 100644
--- a/packages/validation/tests/Rules/EvenRuleTest.php
+++ b/packages/validation/tests/Rules/IsEvenNumberTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Even;
+use Tempest\Validation\Rules\IsEvenNumber;
 
 /**
  * @internal
  */
-final class EvenRuleTest extends TestCase
+final class IsEvenNumberTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new Even();
+        $rule = new IsEvenNumber();
 
         $this->assertTrue($rule->isValid(4));
         $this->assertTrue($rule->isValid(2));
@@ -22,7 +22,5 @@ public function test_it_works(): void
 
         $this->assertFalse($rule->isValid(1));
         $this->assertFalse($rule->isValid(3));
-
-        $this->assertSame('Value should be an even number', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/ShouldBeFalseTest.php b/packages/validation/tests/Rules/IsFalsyTest.php
similarity index 64%
rename from packages/validation/tests/Rules/ShouldBeFalseTest.php
rename to packages/validation/tests/Rules/IsFalsyTest.php
index d2f079648..52efa2303 100644
--- a/packages/validation/tests/Rules/ShouldBeFalseTest.php
+++ b/packages/validation/tests/Rules/IsFalsyTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\ShouldBeFalse;
+use Tempest\Validation\Rules\IsFalsy;
 
 /**
  * @internal
  */
-final class ShouldBeFalseTest extends TestCase
+final class IsFalsyTest extends TestCase
 {
     public function test_should_be_false(): void
     {
-        $rule = new ShouldBeFalse();
+        $rule = new IsFalsy();
 
         $this->assertFalse($rule->isValid(true));
         $this->assertFalse($rule->isValid('true'));
@@ -24,12 +24,8 @@ public function test_should_be_false(): void
         $this->assertTrue($rule->isValid('false'));
         $this->assertTrue($rule->isValid(0));
         $this->assertTrue($rule->isValid('0'));
-    }
-
-    public function test_should_be_false_message(): void
-    {
-        $rule = new ShouldBeFalse();
-
-        $this->assertSame('Value should represent a boolean false value.', $rule->message());
+        $this->assertTrue($rule->isValid('no'));
+        $this->assertTrue($rule->isValid('disabled'));
+        $this->assertTrue($rule->isValid('off'));
     }
 }
diff --git a/packages/validation/tests/Rules/HexColorTest.php b/packages/validation/tests/Rules/IsHexColorTest.php
similarity index 79%
rename from packages/validation/tests/Rules/HexColorTest.php
rename to packages/validation/tests/Rules/IsHexColorTest.php
index b64e286a8..228bac6db 100644
--- a/packages/validation/tests/Rules/HexColorTest.php
+++ b/packages/validation/tests/Rules/IsHexColorTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\HexColor;
+use Tempest\Validation\Rules\IsHexColor;
 
 /**
  * @internal
  */
-final class HexColorTest extends TestCase
+final class IsHexColorTest extends TestCase
 {
     public function test_uuid(): void
     {
-        $rule = new HexColor();
-
-        $this->assertSame('Value should be a valid hexadecimal color.', $rule->message());
+        $rule = new IsHexColor();
 
         $this->assertFalse($rule->isValid('string_123'));
         $this->assertFalse($rule->isValid([])); // Should return false, not a TypeError from preg_match
diff --git a/packages/validation/tests/Rules/IsIPTest.php b/packages/validation/tests/Rules/IsIPTest.php
new file mode 100644
index 000000000..75845a2b9
--- /dev/null
+++ b/packages/validation/tests/Rules/IsIPTest.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Tests\Rules;
+
+use PHPUnit\Framework\TestCase;
+use Tempest\Validation\Rules\IsIP;
+
+/**
+ * @internal
+ */
+final class IsIPTest extends TestCase
+{
+    public function test_ip_address(): void
+    {
+        $rule = new IsIP();
+
+        $this->assertTrue($rule->isValid('192.168.0.1'));
+        $this->assertTrue($rule->isValid('10.0.0.1'));
+        $this->assertTrue($rule->isValid('172.16.0.1'));
+        $this->assertTrue($rule->isValid('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
+        $this->assertTrue($rule->isValid('2001:db8:85a3::8a2e:370:7334'));
+
+        $this->assertFalse($rule->isValid('256.0.0.1'));
+        $this->assertFalse($rule->isValid('300.168.0.1'));
+        $this->assertFalse($rule->isValid('192.168.0'));
+        $this->assertFalse($rule->isValid('192.168.0.1.2'));
+        $this->assertFalse($rule->isValid('192.168.0.1/24'));
+    }
+}
diff --git a/packages/validation/tests/Rules/IsIPv4Test.php b/packages/validation/tests/Rules/IsIPv4Test.php
new file mode 100644
index 000000000..34eb5278a
--- /dev/null
+++ b/packages/validation/tests/Rules/IsIPv4Test.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Tests\Rules;
+
+use PHPUnit\Framework\TestCase;
+use Tempest\Validation\Rules\IsIPv4;
+
+/**
+ * @internal
+ */
+final class IsIPv4Test extends TestCase
+{
+    public function test_ipv4_address(): void
+    {
+        $rule = new IsIPv4();
+
+        $this->assertTrue($rule->isValid('192.168.0.1'));
+        $this->assertTrue($rule->isValid('10.0.0.1'));
+        $this->assertTrue($rule->isValid('172.16.0.1'));
+
+        $this->assertFalse($rule->isValid('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
+        $this->assertFalse($rule->isValid('2001:db8:85a3::8a2e:370:7334'));
+    }
+
+    public function test_ip_address_without_private_range(): void
+    {
+        $rule = new IsIPv4(allowPrivateRange: false);
+
+        $this->assertFalse($rule->isValid('192.168.1.1'));
+        $this->assertTrue($rule->isValid('210.221.151.70'));
+    }
+
+    public function test_ip_address_without_reserved_range(): void
+    {
+        $rule = new IsIPv4(allowReservedRange: false);
+
+        $this->assertFalse($rule->isValid('169.254.0.0'));
+        $this->assertTrue($rule->isValid('172.16.1.1'));
+    }
+}
diff --git a/packages/validation/tests/Rules/IPv6Test.php b/packages/validation/tests/Rules/IsIPv6Test.php
similarity index 53%
rename from packages/validation/tests/Rules/IPv6Test.php
rename to packages/validation/tests/Rules/IsIPv6Test.php
index 416893ac9..bef3f9402 100644
--- a/packages/validation/tests/Rules/IPv6Test.php
+++ b/packages/validation/tests/Rules/IsIPv6Test.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\IPv6;
+use Tempest\Validation\Rules\IsIPv6;
 
 /**
  * @internal
  */
-final class IPv6Test extends TestCase
+final class IsIPv6Test extends TestCase
 {
     public function test_ipv6_address(): void
     {
-        $rule = new IPv6();
-
-        $this->assertSame('Value should be a valid IPv6 address', $rule->message());
+        $rule = new IsIPv6();
 
         $this->assertTrue($rule->isValid('2001:0db8:85a3:0000:0000:8a2e:0370:7334'));
         $this->assertTrue($rule->isValid('2a03:b0c0:3:d0::11f5:3001'));
@@ -28,38 +26,23 @@ public function test_ipv6_address(): void
 
     public function test_ip_address_without_private_range(): void
     {
-        $rule = new IPv6(allowPrivateRange: false);
+        $rule = new IsIPv6(allowPrivateRange: false);
         $this->assertFalse($rule->isValid('fd36:ecf4:e32b:5e21:aaaa:aaaa:aaaa:aaaa'));
         $this->assertTrue($rule->isValid('2a03:b0c0:3:d0::11f5:3001'));
 
-        $rule = new IPv6(allowPrivateRange: true);
+        $rule = new IsIPv6(allowPrivateRange: true);
         $this->assertTrue($rule->isValid('fd36:ecf4:e32b:5e21:aaaa:aaaa:aaaa:aaaa'));
         $this->assertTrue($rule->isValid('2a03:b0c0:3:d0::11f5:3001'));
     }
 
     public function test_ip_address_without_reserved_range(): void
     {
-        $rule = new IPv6(allowReservedRange: false);
+        $rule = new IsIPv6(allowReservedRange: false);
         $this->assertFalse($rule->isValid('::1'));
         $this->assertTrue($rule->isValid('2a03:b0c0:3:d0::11f5:3001'));
 
-        $rule = new IPv6(allowReservedRange: true);
+        $rule = new IsIPv6(allowReservedRange: true);
         $this->assertTrue($rule->isValid('2001:db8:ffff:ffff:ffff:ffff:ffff:ffff'));
         $this->assertTrue($rule->isValid('2a03:b0c0:3:d0::11f5:3001'));
     }
-
-    public function test_messages(): void
-    {
-        $rule = new IPv6();
-        $this->assertSame('Value should be a valid IPv6 address', $rule->message());
-
-        $rule = new IPv6(allowPrivateRange: false);
-        $this->assertSame('Value should be a valid IPv6 address that is not in a private range', $rule->message());
-
-        $rule = new IPv6(allowReservedRange: false);
-        $this->assertSame('Value should be a valid IPv6 address that is not in a reserved range', $rule->message());
-
-        $rule = new IPv6(allowPrivateRange: false, allowReservedRange: false);
-        $this->assertSame('Value should be a valid IPv6 address that is not in a private range and not in a reserved range', $rule->message());
-    }
 }
diff --git a/packages/validation/tests/Rules/InTest.php b/packages/validation/tests/Rules/IsInTest.php
similarity index 69%
rename from packages/validation/tests/Rules/InTest.php
rename to packages/validation/tests/Rules/IsInTest.php
index 37913f065..401294e9b 100644
--- a/packages/validation/tests/Rules/InTest.php
+++ b/packages/validation/tests/Rules/IsInTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\In;
+use Tempest\Validation\Rules\IsIn;
 
 /**
  * @internal
  */
-final class InTest extends TestCase
+final class IsInTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new In([4, 2, 0]);
+        $rule = new IsIn([4, 2, 0]);
 
         $this->assertTrue($rule->isValid(4));
         $this->assertTrue($rule->isValid(2));
@@ -22,7 +22,5 @@ public function test_it_works(): void
 
         $this->assertFalse($rule->isValid(1));
         $this->assertFalse($rule->isValid(3));
-
-        $this->assertSame('Value should be one of: 4, 2, 0', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/JSONTest.php b/packages/validation/tests/Rules/IsJsonStringTest.php
similarity index 68%
rename from packages/validation/tests/Rules/JSONTest.php
rename to packages/validation/tests/Rules/IsJsonStringTest.php
index 7c31e0248..0003c143f 100644
--- a/packages/validation/tests/Rules/JSONTest.php
+++ b/packages/validation/tests/Rules/IsJsonStringTest.php
@@ -5,23 +5,23 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Json;
+use Tempest\Validation\Rules\IsJsonString;
 use ValueError;
 
 /**
  * @internal
  */
-final class JSONTest extends TestCase
+final class IsJsonStringTest extends TestCase
 {
     public function test_it_returns_true_for_valid_json_string(): void
     {
-        $rule = new Json();
+        $rule = new IsJsonString();
         $this->assertTrue($rule->isValid('{"test": "test"}'));
     }
 
     public function test_it_returns_false_for_invalid_json_string(): void
     {
-        $rule = new Json();
+        $rule = new IsJsonString();
         $this->assertFalse($rule->isValid('{"test": test}'));
     }
 
@@ -29,7 +29,7 @@ public function test_it_allows_to_specify_depth(): void
     {
         // Not sure if there is a better way of asserting that a php function was called with a given argument
         $this->expectException(ValueError::class);
-        $rule = new Json(depth: 0); // we intentionally send something that is not valid
+        $rule = new IsJsonString(depth: 0); // we intentionally send something that is not valid
         $rule->isValid('{"test": "test"}');
     }
 
@@ -37,13 +37,7 @@ public function test_it_allows_to_specify_flags(): void
     {
         // Not sure if there is a better way of asserting that a php function was called with a given argument
         $this->expectException(ValueError::class);
-        $rule = new Json(flags: 232312312); // we intentionally send something that is not valid
+        $rule = new IsJsonString(flags: 232312312); // we intentionally send something that is not valid
         $rule->isValid('{"test": "test"}');
     }
-
-    public function test_it_returns_the_proper_message(): void
-    {
-        $rule = new Json();
-        $this->assertEquals('Value should be a valid JSON string', $rule->message());
-    }
 }
diff --git a/packages/validation/tests/Rules/LowercaseTest.php b/packages/validation/tests/Rules/IsLowercaseTest.php
similarity index 69%
rename from packages/validation/tests/Rules/LowercaseTest.php
rename to packages/validation/tests/Rules/IsLowercaseTest.php
index cdd4945a8..91f38d121 100644
--- a/packages/validation/tests/Rules/LowercaseTest.php
+++ b/packages/validation/tests/Rules/IsLowercaseTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Lowercase;
+use Tempest\Validation\Rules\IsLowercase;
 
 /**
  * @internal
  */
-final class LowercaseTest extends TestCase
+final class IsLowercaseTest extends TestCase
 {
     public function test_lowercase(): void
     {
-        $rule = new Lowercase();
-
-        $this->assertSame('Value should be a lowercase string', $rule->message());
+        $rule = new IsLowercase();
 
         $this->assertTrue($rule->isValid('abc'));
         $this->assertTrue($rule->isValid('àbç'));
diff --git a/packages/validation/tests/Rules/MACAddressTest.php b/packages/validation/tests/Rules/IsMacAddressTest.php
similarity index 80%
rename from packages/validation/tests/Rules/MACAddressTest.php
rename to packages/validation/tests/Rules/IsMacAddressTest.php
index 77105a87f..a2903e49d 100644
--- a/packages/validation/tests/Rules/MACAddressTest.php
+++ b/packages/validation/tests/Rules/IsMacAddressTest.php
@@ -5,18 +5,17 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\MACAddress;
+use Tempest\Validation\Rules\IsMacAddress;
 
 /**
  * @internal
  */
-final class MACAddressTest extends TestCase
+final class IsMacAddressTest extends TestCase
 {
     public function test_ip_address(): void
     {
-        $rule = new MACAddress();
+        $rule = new IsMacAddress();
 
-        $this->assertSame('Value should be a valid MAC Address', $rule->message());
         $this->assertTrue($rule->isValid('00:1A:2B:3C:4D:5E'));
         $this->assertTrue($rule->isValid('01-23-45-67-89-AB'));
         $this->assertTrue($rule->isValid('A1:B2:C3:D4:E5:F6'));
diff --git a/packages/validation/tests/Rules/MultipleOfTest.php b/packages/validation/tests/Rules/IsMultipleOfTest.php
similarity index 70%
rename from packages/validation/tests/Rules/MultipleOfTest.php
rename to packages/validation/tests/Rules/IsMultipleOfTest.php
index e50bfcc72..bc887ce58 100644
--- a/packages/validation/tests/Rules/MultipleOfTest.php
+++ b/packages/validation/tests/Rules/IsMultipleOfTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\MultipleOf;
+use Tempest\Validation\Rules\IsMultipleOf;
 
 /**
  * @internal
  */
-final class MultipleOfTest extends TestCase
+final class IsMultipleOfTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new MultipleOf(5);
+        $rule = new IsMultipleOf(5);
 
         $this->assertTrue($rule->isValid(10));
         $this->assertTrue($rule->isValid(5));
@@ -23,7 +23,5 @@ public function test_it_works(): void
         $this->assertFalse($rule->isValid(3));
         $this->assertFalse($rule->isValid(4));
         $this->assertFalse($rule->isValid(6));
-
-        $this->assertSame('Value should be a multiple of 5', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/NotEmptyTest.php b/packages/validation/tests/Rules/IsNotEmptyStringTest.php
similarity index 70%
rename from packages/validation/tests/Rules/NotEmptyTest.php
rename to packages/validation/tests/Rules/IsNotEmptyStringTest.php
index f5dd77078..bbbcf52ac 100644
--- a/packages/validation/tests/Rules/NotEmptyTest.php
+++ b/packages/validation/tests/Rules/IsNotEmptyStringTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\NotEmpty;
+use Tempest\Validation\Rules\IsNotEmptyString;
 
 /**
  * @internal
  */
-final class NotEmptyTest extends TestCase
+final class IsNotEmptyStringTest extends TestCase
 {
     public function test_not_empty(): void
     {
-        $rule = new NotEmpty();
+        $rule = new IsNotEmptyString();
 
         $this->assertTrue($rule->isValid('t'));
         $this->assertFalse($rule->isValid(''));
diff --git a/packages/validation/tests/Rules/OddRuleTest.php b/packages/validation/tests/Rules/IsNotInTest.php
similarity index 70%
rename from packages/validation/tests/Rules/OddRuleTest.php
rename to packages/validation/tests/Rules/IsNotInTest.php
index fe463c0ee..160de3750 100644
--- a/packages/validation/tests/Rules/OddRuleTest.php
+++ b/packages/validation/tests/Rules/IsNotInTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Odd;
+use Tempest\Validation\Rules\IsNotIn;
 
 /**
  * @internal
  */
-final class OddRuleTest extends TestCase
+final class IsNotInTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new Odd();
+        $rule = new IsNotIn([4, 2, 0]);
 
         $this->assertFalse($rule->isValid(4));
         $this->assertFalse($rule->isValid(2));
@@ -22,7 +22,5 @@ public function test_it_works(): void
 
         $this->assertTrue($rule->isValid(1));
         $this->assertTrue($rule->isValid(3));
-
-        $this->assertSame('Value should be an odd number', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/NotInTest.php b/packages/validation/tests/Rules/IsOddNumberTest.php
similarity index 68%
rename from packages/validation/tests/Rules/NotInTest.php
rename to packages/validation/tests/Rules/IsOddNumberTest.php
index a2ef81b84..57d2e3c05 100644
--- a/packages/validation/tests/Rules/NotInTest.php
+++ b/packages/validation/tests/Rules/IsOddNumberTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\NotIn;
+use Tempest\Validation\Rules\IsOddNumber;
 
 /**
  * @internal
  */
-final class NotInTest extends TestCase
+final class IsOddNumberTest extends TestCase
 {
     public function test_it_works(): void
     {
-        $rule = new NotIn([4, 2, 0]);
+        $rule = new IsOddNumber();
 
         $this->assertFalse($rule->isValid(4));
         $this->assertFalse($rule->isValid(2));
@@ -22,7 +22,5 @@ public function test_it_works(): void
 
         $this->assertTrue($rule->isValid(1));
         $this->assertTrue($rule->isValid(3));
-
-        $this->assertSame('Value cannot be any of: 4, 2, 0', $rule->message());
     }
 }
diff --git a/packages/validation/tests/Rules/IsPasswordTest.php b/packages/validation/tests/Rules/IsPasswordTest.php
new file mode 100644
index 000000000..09b306e65
--- /dev/null
+++ b/packages/validation/tests/Rules/IsPasswordTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Validation\Tests\Rules;
+
+use PHPUnit\Framework\TestCase;
+use Tempest\Validation\Rules\IsPassword;
+
+/**
+ * @internal
+ */
+final class IsPasswordTest extends TestCase
+{
+    public function test_defaults(): void
+    {
+        $rule = new IsPassword();
+
+        $this->assertTrue($rule->isValid('123456789012'));
+        $this->assertTrue($rule->isValid('aaaaaaaaaaaa'));
+    }
+
+    public function test_invalid_input(): void
+    {
+        $rule = new IsPassword();
+        $this->assertFalse($rule->isValid(123456789012));
+        $this->assertFalse($rule->isValid([123456789012]));
+    }
+
+    public function test_minimum(): void
+    {
+        $rule = new IsPassword(min: 4);
+        $this->assertTrue($rule->isValid('12345'));
+        $this->assertTrue($rule->isValid('1234'));
+        $this->assertFalse($rule->isValid('123'));
+    }
+
+    public function test_mixed_case(): void
+    {
+        $rule = new IsPassword(mixedCase: true);
+        $this->assertTrue($rule->isValid('abcdEFGHIJKL'));
+        $this->assertFalse($rule->isValid('abcdefghijkl'));
+        $this->assertFalse($rule->isValid('ABCDEFGHIJKL'));
+    }
+
+    public function test_letters(): void
+    {
+        $rule = new IsPassword(letters: true);
+        $this->assertTrue($rule->isValid('12345678901a'));
+        $this->assertFalse($rule->isValid('123456789012'));
+    }
+
+    public function test_numbers(): void
+    {
+        $rule = new IsPassword(numbers: true);
+        $this->assertTrue($rule->isValid('123456789012'));
+        $this->assertTrue($rule->isValid('1aaaaaaaaaaa'));
+        $this->assertFalse($rule->isValid('abcdefghijkl'));
+    }
+
+    public function test_symbols(): void
+    {
+        $rule = new IsPassword(symbols: true);
+        $this->assertTrue($rule->isValid('123456789012@'));
+        $this->assertFalse($rule->isValid('123456789012'));
+    }
+}
diff --git a/packages/validation/tests/Rules/PhoneNumberTest.php b/packages/validation/tests/Rules/IsPhoneNumberTest.php
similarity index 56%
rename from packages/validation/tests/Rules/PhoneNumberTest.php
rename to packages/validation/tests/Rules/IsPhoneNumberTest.php
index eda3fcae5..7c796e590 100644
--- a/packages/validation/tests/Rules/PhoneNumberTest.php
+++ b/packages/validation/tests/Rules/IsPhoneNumberTest.php
@@ -5,32 +5,28 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\PhoneNumber;
+use Tempest\Validation\Rules\IsPhoneNumber;
 
 /**
  * @internal
  */
-final class PhoneNumberTest extends TestCase
+final class IsPhoneNumberTest extends TestCase
 {
     public function test_phone_number(): void
     {
-        $rule = new PhoneNumber();
-
-        $this->assertSame('Value should be a valid phone number', $rule->message());
+        $rule = new IsPhoneNumber();
 
         $this->assertFalse($rule->isValid('this is not a phone number'));
         $this->assertFalse($rule->isValid('john.doe@example.com'));
         $this->assertTrue($rule->isValid('+1 (805) 380-4329'));
         $this->assertTrue($rule->isValid('+32 0497 88 93 11'));
 
-        $rule = new PhoneNumber('US');
+        $rule = new IsPhoneNumber('US');
 
-        $this->assertSame('Value should be a valid US phone number', $rule->message());
         $this->assertTrue($rule->isValid('(805) 380-4329'));
 
-        $rule = new PhoneNumber('BE');
+        $rule = new IsPhoneNumber('BE');
 
-        $this->assertSame('Value should be a valid BE phone number', $rule->message());
         $this->assertTrue($rule->isValid('0497 88 93 11'));
     }
 }
diff --git a/packages/validation/tests/Rules/IsStringTest.php b/packages/validation/tests/Rules/IsStringTest.php
index b693f7715..2d4320df6 100644
--- a/packages/validation/tests/Rules/IsStringTest.php
+++ b/packages/validation/tests/Rules/IsStringTest.php
@@ -20,7 +20,6 @@ public function test_valid_non_nullable_string(): void
         $this->assertTrue($rule->isValid('test string'));
         $this->assertFalse($rule->isValid(false));
         $this->assertFalse($rule->isValid([]));
-        $this->assertSame('Value should be a string', $rule->message());
     }
 
     public function test_valid_nullable_string(): void
diff --git a/packages/validation/tests/Rules/TimeTest.php b/packages/validation/tests/Rules/IsTimeTest.php
similarity index 89%
rename from packages/validation/tests/Rules/TimeTest.php
rename to packages/validation/tests/Rules/IsTimeTest.php
index 54d41dc14..9b0987e48 100644
--- a/packages/validation/tests/Rules/TimeTest.php
+++ b/packages/validation/tests/Rules/IsTimeTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Time;
+use Tempest\Validation\Rules\IsTime;
 
 /**
  * @internal
  */
-final class TimeTest extends TestCase
+final class IsTimeTest extends TestCase
 {
     public function test_time(): void
     {
-        $rule = new Time();
-
-        $this->assertSame('Value should be a valid time in the format of hh:mm xm', $rule->message());
+        $rule = new IsTime(twentyFourHour: false);
 
         $this->assertFalse($rule->isValid('0001'));
         $this->assertFalse($rule->isValid('01:00'));
@@ -40,9 +38,7 @@ public function test_time(): void
 
     public function test_military_time(): void
     {
-        $rule = new Time(twentyFourHour: true);
-
-        $this->assertSame('Value should be a valid time in the 24-hour format of hh:mm', $rule->message());
+        $rule = new IsTime(twentyFourHour: true);
 
         $this->assertFalse($rule->isValid('2400'));
         $this->assertFalse($rule->isValid('01:00 am'));
@@ -86,7 +82,7 @@ public function test_military_time(): void
 
     public function test_non_string_pregmatch_subject(): void
     {
-        $rule = new Time(twentyFourHour: true);
+        $rule = new IsTime(twentyFourHour: true);
 
         $this->assertFalse($rule->isValid([]));
         $this->assertFalse($rule->isValid(new \stdClass()));
diff --git a/packages/validation/tests/Rules/TimezoneTest.php b/packages/validation/tests/Rules/IsTimezoneTest.php
similarity index 78%
rename from packages/validation/tests/Rules/TimezoneTest.php
rename to packages/validation/tests/Rules/IsTimezoneTest.php
index 391a9d535..6d4459405 100644
--- a/packages/validation/tests/Rules/TimezoneTest.php
+++ b/packages/validation/tests/Rules/IsTimezoneTest.php
@@ -6,18 +6,16 @@
 
 use DateTimeZone;
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Timezone;
+use Tempest\Validation\Rules\IsTimezone;
 
 /**
  * @internal
  */
-final class TimezoneTest extends TestCase
+final class IsTimezoneTest extends TestCase
 {
     public function test_timezone(): void
     {
-        $rule = new Timezone();
-
-        $this->assertSame('Value should be a valid timezone', $rule->message());
+        $rule = new IsTimezone();
 
         $this->assertFalse($rule->isValid('invalid_timezone'));
         $this->assertFalse($rule->isValid('Asia/Sydney'));
@@ -29,13 +27,13 @@ public function test_timezone(): void
 
     public function test_timezone_with_country_code(): void
     {
-        $rule = new Timezone(DateTimeZone::PER_COUNTRY, 'AU');
+        $rule = new IsTimezone(DateTimeZone::PER_COUNTRY, 'AU');
 
         $this->assertFalse($rule->isValid('America/New_York'));
         $this->assertTrue($rule->isValid('Australia/Sydney'));
         $this->assertTrue($rule->isValid('Australia/Melbourne'));
 
-        $rule = new Timezone(DateTimeZone::PER_COUNTRY, 'US');
+        $rule = new IsTimezone(DateTimeZone::PER_COUNTRY, 'US');
 
         $this->assertFalse($rule->isValid('Europe/Paris'));
         $this->assertTrue($rule->isValid('America/New_York'));
@@ -45,14 +43,14 @@ public function test_timezone_with_country_code(): void
 
     public function test_timezone_with_group(): void
     {
-        $rule = new Timezone(DateTimeZone::ASIA);
+        $rule = new IsTimezone(DateTimeZone::ASIA);
 
         $this->assertFalse($rule->isValid('Africa/Nairobi'));
         $this->assertTrue($rule->isValid('Asia/Tokyo'));
         $this->assertTrue($rule->isValid('Asia/Hong_Kong'));
         $this->assertTrue($rule->isValid('Asia/Singapore'));
 
-        $rule = new Timezone(DateTimeZone::INDIAN);
+        $rule = new IsTimezone(DateTimeZone::INDIAN);
 
         $this->assertFalse($rule->isValid('Europe/Paris'));
         $this->assertTrue($rule->isValid('Indian/Reunion'));
diff --git a/packages/validation/tests/Rules/ShouldBeTrueTest.php b/packages/validation/tests/Rules/IsTruthyTest.php
similarity index 64%
rename from packages/validation/tests/Rules/ShouldBeTrueTest.php
rename to packages/validation/tests/Rules/IsTruthyTest.php
index 070dbf965..d0160272c 100644
--- a/packages/validation/tests/Rules/ShouldBeTrueTest.php
+++ b/packages/validation/tests/Rules/IsTruthyTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\ShouldBeTrue;
+use Tempest\Validation\Rules\IsTruthy;
 
 /**
  * @internal
  */
-final class ShouldBeTrueTest extends TestCase
+final class IsTruthyTest extends TestCase
 {
     public function test_should_be_true(): void
     {
-        $rule = new ShouldBeTrue();
+        $rule = new IsTruthy();
 
         $this->assertFalse($rule->isValid(false));
         $this->assertFalse($rule->isValid('false'));
@@ -24,12 +24,8 @@ public function test_should_be_true(): void
         $this->assertTrue($rule->isValid('true'));
         $this->assertTrue($rule->isValid(1));
         $this->assertTrue($rule->isValid('1'));
-    }
-
-    public function test_should_be_true_message(): void
-    {
-        $rule = new ShouldBeTrue();
-
-        $this->assertSame('Value should represent a boolean true value.', $rule->message());
+        $this->assertTrue($rule->isValid('yes'));
+        $this->assertTrue($rule->isValid('enabled'));
+        $this->assertTrue($rule->isValid('on'));
     }
 }
diff --git a/packages/validation/tests/Rules/UlidTest.php b/packages/validation/tests/Rules/IsUlidTest.php
similarity index 68%
rename from packages/validation/tests/Rules/UlidTest.php
rename to packages/validation/tests/Rules/IsUlidTest.php
index f1e3903bc..448604674 100644
--- a/packages/validation/tests/Rules/UlidTest.php
+++ b/packages/validation/tests/Rules/IsUlidTest.php
@@ -5,24 +5,22 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Ulid;
+use Tempest\Validation\Rules\IsUlid;
 
 /**
  * @internal
  */
-final class UlidTest extends TestCase
+final class IsUlidTest extends TestCase
 {
     public function test_ulid(): void
     {
-        $rule = new Ulid();
-
-        $this->assertSame('Value should be a valid ULID', $rule->message());
+        $rule = new IsUlid();
 
         $this->assertTrue($rule->isValid('01FV8CE8P3XVZTVK0S6F05Z5ZA'));
         $this->assertTrue($rule->isValid('01fv8ce8p3xvztvk0S6f05z5za'));
         $this->assertFalse($rule->isValid('01FV8CE8P3XVZTVK0S6F05Z5ZU')); // contains invalid character
         $this->assertFalse($rule->isValid('01FV8CE8P3XVZTVK0S6F05')); // too short
         $this->assertFalse($rule->isValid('01FV8CE8P3XVZTVK0S6F05Z5ZAAAAA')); // too long
-        $this->assertFalse($rule->isValid([])); // Should return false, not a TypeError from preg_match
+        $this->assertFalse($rule->isValid([]));
     }
 }
diff --git a/packages/validation/tests/Rules/TimestampTest.php b/packages/validation/tests/Rules/IsUnixTimestampTest.php
similarity index 50%
rename from packages/validation/tests/Rules/TimestampTest.php
rename to packages/validation/tests/Rules/IsUnixTimestampTest.php
index 05cf15fa3..5e926bebb 100644
--- a/packages/validation/tests/Rules/TimestampTest.php
+++ b/packages/validation/tests/Rules/IsUnixTimestampTest.php
@@ -5,25 +5,18 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Timestamp;
+use Tempest\Validation\Rules\IsUnixTimestamp;
 
 /**
  * @internal
  */
-final class TimestampTest extends TestCase
+final class IsUnixTimestampTest extends TestCase
 {
     public function test_timestamp(): void
     {
-        $rule = new Timestamp();
+        $rule = new IsUnixTimestamp();
 
         $this->assertTrue($rule->isValid(time()));
         $this->assertFalse($rule->isValid('2021-01-01'));
     }
-
-    public function test_timestamp_message(): void
-    {
-        $rule = new Timestamp();
-
-        $this->assertSame('Value should be a valid timestamp', $rule->message());
-    }
 }
diff --git a/packages/validation/tests/Rules/UppercaseTest.php b/packages/validation/tests/Rules/IsUppercaseTest.php
similarity index 68%
rename from packages/validation/tests/Rules/UppercaseTest.php
rename to packages/validation/tests/Rules/IsUppercaseTest.php
index 2f9fc4949..6fe8f5836 100644
--- a/packages/validation/tests/Rules/UppercaseTest.php
+++ b/packages/validation/tests/Rules/IsUppercaseTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Uppercase;
+use Tempest\Validation\Rules\IsUppercase;
 
 /**
  * @internal
  */
-final class UppercaseTest extends TestCase
+final class IsUppercaseTest extends TestCase
 {
     public function test_uppercase(): void
     {
-        $rule = new Uppercase();
-
-        $this->assertSame('Value should be an uppercase string', $rule->message());
+        $rule = new IsUppercase();
 
         $this->assertTrue($rule->isValid('ABC'));
         $this->assertTrue($rule->isValid('ÀBÇ'));
diff --git a/packages/validation/tests/Rules/UrlTest.php b/packages/validation/tests/Rules/IsUrlTest.php
similarity index 70%
rename from packages/validation/tests/Rules/UrlTest.php
rename to packages/validation/tests/Rules/IsUrlTest.php
index a0bc0cf32..11c182dbb 100644
--- a/packages/validation/tests/Rules/UrlTest.php
+++ b/packages/validation/tests/Rules/IsUrlTest.php
@@ -5,16 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Url;
+use Tempest\Validation\Rules\IsUrl;
 
 /**
  * @internal
  */
-final class UrlTest extends TestCase
+final class IsUrlTest extends TestCase
 {
     public function test_url(): void
     {
-        $rule = new Url();
+        $rule = new IsUrl();
 
         $this->assertFalse($rule->isValid('this is not a url'));
         $this->assertFalse($rule->isValid('https://https://example.com'));
@@ -24,7 +24,7 @@ public function test_url(): void
 
     public function test_url_with_restricted_protocols(): void
     {
-        $rule = new Url(['https']);
+        $rule = new IsUrl(['https']);
 
         $this->assertFalse($rule->isValid('http://example.com'));
         $this->assertTrue($rule->isValid('https://example.com'));
@@ -32,15 +32,8 @@ public function test_url_with_restricted_protocols(): void
 
     public function test_url_with_integer_value(): void
     {
-        $rule = new Url();
+        $rule = new IsUrl();
 
         $this->assertFalse($rule->isValid(1));
     }
-
-    public function test_url_message(): void
-    {
-        $rule = new Url();
-
-        $this->assertSame('Value should be a valid URL', $rule->message());
-    }
 }
diff --git a/packages/validation/tests/Rules/UuidTest.php b/packages/validation/tests/Rules/IsUuidTest.php
similarity index 83%
rename from packages/validation/tests/Rules/UuidTest.php
rename to packages/validation/tests/Rules/IsUuidTest.php
index c496c1c59..65cb7a7f6 100644
--- a/packages/validation/tests/Rules/UuidTest.php
+++ b/packages/validation/tests/Rules/IsUuidTest.php
@@ -5,18 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Uuid;
+use Tempest\Validation\Rules\IsUuid;
 
 /**
  * @internal
  */
-final class UuidTest extends TestCase
+final class IsUuidTest extends TestCase
 {
     public function test_uuid(): void
     {
-        $rule = new Uuid();
-
-        $this->assertSame('Value should contain a valid UUID', $rule->message());
+        $rule = new IsUuid();
 
         $this->assertFalse($rule->isValid('string_123'));
         $this->assertFalse($rule->isValid([])); // Should return false, not a TypeError from preg_match
diff --git a/packages/validation/tests/Rules/RegexTest.php b/packages/validation/tests/Rules/MatchesRegExTest.php
similarity index 71%
rename from packages/validation/tests/Rules/RegexTest.php
rename to packages/validation/tests/Rules/MatchesRegExTest.php
index 350080fe8..06971c5dc 100644
--- a/packages/validation/tests/Rules/RegexTest.php
+++ b/packages/validation/tests/Rules/MatchesRegExTest.php
@@ -5,21 +5,16 @@
 namespace Tempest\Validation\Tests\Rules;
 
 use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\RegEx;
+use Tempest\Validation\Rules\MatchesRegEx;
 
 /**
  * @internal
  */
-final class RegexTest extends TestCase
+final class MatchesRegExTest extends TestCase
 {
     public function test_regex_rule(): void
     {
-        $rule = new RegEx('/^[aA][bB]$/');
-
-        $this->assertSame(
-            'The value must match the regular expression pattern: /^[aA][bB]$/',
-            $rule->message(),
-        );
+        $rule = new MatchesRegEx('/^[aA][bB]$/');
 
         $this->assertFalse($rule->isValid('cd'));
         $this->assertFalse($rule->isValid('za'));
@@ -31,7 +26,7 @@ public function test_regex_rule(): void
 
     public function test_non_imvalid_types(): void
     {
-        $rule = new RegEx('/^[0-9]+$/');
+        $rule = new MatchesRegEx('/^[0-9]+$/');
 
         // Invalid types should return false, not a TypeError.
         $this->assertFalse($rule->isValid(false));
diff --git a/packages/validation/tests/Rules/PasswordTest.php b/packages/validation/tests/Rules/PasswordTest.php
deleted file mode 100644
index f46502d92..000000000
--- a/packages/validation/tests/Rules/PasswordTest.php
+++ /dev/null
@@ -1,99 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Tests\Rules;
-
-use PHPUnit\Framework\TestCase;
-use Tempest\Validation\Rules\Password;
-
-/**
- * @internal
- */
-final class PasswordTest extends TestCase
-{
-    public function test_defaults(): void
-    {
-        $rule = new Password();
-
-        $this->assertTrue($rule->isValid('123456789012'));
-        $this->assertTrue($rule->isValid('aaaaaaaaaaaa'));
-    }
-
-    public function test_invalid_input(): void
-    {
-        $rule = new Password();
-        $this->assertFalse($rule->isValid(123456789012));
-        $this->assertFalse($rule->isValid([123456789012]));
-    }
-
-    public function test_minimum(): void
-    {
-        $rule = new Password(min: 4);
-        $this->assertTrue($rule->isValid('12345'));
-        $this->assertTrue($rule->isValid('1234'));
-        $this->assertFalse($rule->isValid('123'));
-    }
-
-    public function test_mixed_case(): void
-    {
-        $rule = new Password(mixedCase: true);
-        $this->assertTrue($rule->isValid('abcdEFGHIJKL'));
-        $this->assertFalse($rule->isValid('abcdefghijkl'));
-        $this->assertFalse($rule->isValid('ABCDEFGHIJKL'));
-    }
-
-    public function test_letters(): void
-    {
-        $rule = new Password(letters: true);
-        $this->assertTrue($rule->isValid('12345678901a'));
-        $this->assertFalse($rule->isValid('123456789012'));
-    }
-
-    public function test_numbers(): void
-    {
-        $rule = new Password(numbers: true);
-        $this->assertTrue($rule->isValid('123456789012'));
-        $this->assertTrue($rule->isValid('1aaaaaaaaaaa'));
-        $this->assertFalse($rule->isValid('abcdefghijkl'));
-    }
-
-    public function test_symbols(): void
-    {
-        $rule = new Password(symbols: true);
-        $this->assertTrue($rule->isValid('123456789012@'));
-        $this->assertFalse($rule->isValid('123456789012'));
-    }
-
-    public function test_message(): void
-    {
-        $rule = new Password();
-        $this->assertSame('Value should contain at least 12 characters', $rule->message()[0]);
-
-        $rule = new Password(min: 4);
-        $this->assertSame('Value should contain at least 4 characters', $rule->message()[0]);
-
-        $rule = new Password(mixedCase: true);
-        $this->assertSame('Value should contain at least 12 characters', $rule->message()[0]);
-        $this->assertSame('at least one uppercase and one lowercase letter', $rule->message()[1]);
-
-        $rule = new Password(letters: true);
-        $this->assertSame('Value should contain at least 12 characters', $rule->message()[0]);
-        $this->assertSame('at least one letter', $rule->message()[1]);
-
-        $rule = new Password(numbers: true);
-        $this->assertSame('Value should contain at least 12 characters', $rule->message()[0]);
-        $this->assertSame('at least one number', $rule->message()[1]);
-
-        $rule = new Password(symbols: true);
-        $this->assertSame('Value should contain at least 12 characters', $rule->message()[0]);
-        $this->assertSame('at least one symbol', $rule->message()[1]);
-
-        $rule = new Password(min: 4, mixedCase: true, letters: true, numbers: true, symbols: true);
-        $this->assertSame('Value should contain at least 4 characters', $rule->message()[0]);
-        $this->assertSame('at least one uppercase and one lowercase letter', $rule->message()[1]);
-        $this->assertSame('at least one number', $rule->message()[2]);
-        $this->assertSame('at least one letter', $rule->message()[3]);
-        $this->assertSame('at least one symbol', $rule->message()[4]);
-    }
-}
diff --git a/packages/validation/tests/Rules/StartsWithTest.php b/packages/validation/tests/Rules/StartsWithTest.php
index d3b347a4e..35b126c34 100644
--- a/packages/validation/tests/Rules/StartsWithTest.php
+++ b/packages/validation/tests/Rules/StartsWithTest.php
@@ -16,8 +16,6 @@ public function test_starts_with(): void
     {
         $rule = new StartsWith(needle: 'ab');
 
-        $this->assertSame('Value should start with ab', $rule->message());
-
         $this->assertTrue($rule->isValid('ab'));
         $this->assertTrue($rule->isValid('abc'));
         $this->assertFalse($rule->isValid('a'));
diff --git a/packages/validation/tests/ValidationExceptionTest.php b/packages/validation/tests/ValidationExceptionTest.php
deleted file mode 100644
index ed52e020c..000000000
--- a/packages/validation/tests/ValidationExceptionTest.php
+++ /dev/null
@@ -1,79 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tempest\Validation\Tests;
-
-use PHPUnit\Framework\TestCase;
-use stdClass;
-use Tempest\Validation\Exceptions\ValidationFailed;
-use Tempest\Validation\Rule;
-
-/**
- * @internal
- */
-final class ValidationExceptionTest extends TestCase
-{
-    public function test_exception_message(): void
-    {
-        $this->expectException(ValidationFailed::class);
-
-        $this->expectExceptionMessage('Value should be a valid email address');
-
-        throw new ValidationFailed(new stdClass(), [
-            'email' => [
-                new class() implements Rule {
-                    public function isValid(mixed $value): bool
-                    {
-                        return false;
-                    }
-
-                    public function message(): string
-                    {
-                        return 'Value should be a valid email address';
-                    }
-                },
-            ],
-        ]);
-    }
-
-    public function test_exception_message_with_multiple_messages(): void
-    {
-        $this->expectException(ValidationFailed::class);
-
-        $this->expectExceptionMessage('Value should be a valid email address');
-        $this->expectExceptionMessage('Value should praise tempest, old gods from the past and the new gods from the future');
-
-        throw new ValidationFailed(new stdClass(), [
-            'email' => [
-                new class() implements Rule {
-                    public function isValid(mixed $value): bool
-                    {
-                        return false;
-                    }
-
-                    public function message(): string
-                    {
-                        return 'Value should be a valid email address';
-                    }
-                },
-                new class() implements Rule {
-                    public function isValid(mixed $value): bool
-                    {
-                        return false;
-                    }
-
-                    /** @return string[] */
-                    public function message(): array
-                    {
-                        return [
-                            'Value should praise tempest',
-                            'old gods from the past',
-                            'the new gods from the future',
-                        ];
-                    }
-                },
-            ],
-        ]);
-    }
-}
diff --git a/packages/validation/tests/ValidatorTest.php b/packages/validation/tests/ValidatorTest.php
index 1c7125a53..1c460e985 100644
--- a/packages/validation/tests/ValidatorTest.php
+++ b/packages/validation/tests/ValidatorTest.php
@@ -7,13 +7,13 @@
 use PHPUnit\Framework\TestCase;
 use Tempest\Reflection\ClassReflector;
 use Tempest\Validation\Exceptions\ValidationFailed;
-use Tempest\Validation\Rules\Email;
 use Tempest\Validation\Rules\IsBoolean;
+use Tempest\Validation\Rules\IsEmail;
 use Tempest\Validation\Rules\IsEnum;
 use Tempest\Validation\Rules\IsFloat;
 use Tempest\Validation\Rules\IsInteger;
+use Tempest\Validation\Rules\IsNotNull;
 use Tempest\Validation\Rules\IsString;
-use Tempest\Validation\Rules\NotNull;
 use Tempest\Validation\Tests\Fixtures\ObjectToBeValidated;
 use Tempest\Validation\Tests\Fixtures\ObjectWithBoolProp;
 use Tempest\Validation\Tests\Fixtures\ObjectWithEnumProp;
@@ -30,25 +30,27 @@
  */
 final class ValidatorTest extends TestCase
 {
+    private Validator $validator {
+        get => new Validator(new NullTranslator());
+    }
+
     public function test_validate(): void
     {
         $this->expectException(ValidationFailed::class);
 
-        $validator = new Validator();
-
-        $validator->validateObject(new ObjectToBeValidated(name: 'a'));
+        $this->validator->validateObject(new ObjectToBeValidated(name: 'a'));
     }
 
     public function test_validate_value(): void
     {
-        $failingRules = new Validator()->validateValue('a', [new Email()]);
+        $failingRules = $this->validator->validateValue('a', [new IsEmail()]);
 
         $this->assertCount(1, $failingRules);
     }
 
     public function test_closure_fails_with_false_response(): void
     {
-        $failingRules = new Validator()->validateValue('a', function (mixed $_) {
+        $failingRules = $this->validator->validateValue('a', function (mixed $_) {
             return false;
         });
 
@@ -57,17 +59,17 @@ public function test_closure_fails_with_false_response(): void
 
     public function test_closure_fails_with_string_response(): void
     {
-        $failingRules = new Validator()->validateValue('a', function (mixed $_) {
+        $failingRules = $this->validator->validateValue('a', function (mixed $_) {
             return 'I expected b';
         });
 
         $this->assertCount(1, $failingRules);
-        $this->assertSame('I expected b', $failingRules[0]->message());
+        $this->assertSame('I expected b', $failingRules[0]->message);
     }
 
     public function test_closure_passes_with_null_response(): void
     {
-        $validator = new Validator();
+        $validator = $this->validator;
         $validator->validateValue('a', function (mixed $_) {
             return null;
         });
@@ -77,7 +79,7 @@ public function test_closure_passes_with_null_response(): void
 
     public function test_closure_passes_with_true_response(): void
     {
-        $validator = new Validator();
+        $validator = $this->validator;
         $validator->validateValue('a', function (mixed $_) {
             return true;
         });
@@ -87,7 +89,7 @@ public function test_closure_passes_with_true_response(): void
 
     public function test_closure_passes(): void
     {
-        $validator = new Validator();
+        $validator = $this->validator;
 
         $validator->validateValue('a', function (mixed $value) {
             return $value === 'a';
@@ -106,14 +108,14 @@ public function test_closure_passes(): void
 
     public function test_nested_property_validation(): void
     {
-        $validator = new Validator();
+        $validator = $this->validator;
 
         $class = new ClassReflector(ValidateObjectA::class);
 
         $failingRules = $validator->validateValuesForClass($class, []);
 
         $this->assertCount(7, $failingRules);
-        $this->assertInstanceOf(NotNull::class, $failingRules['b'][0]);
+        $this->assertInstanceOf(IsNotNull::class, $failingRules['b'][0]);
         $this->assertInstanceOf(IsString::class, $failingRules['title'][0]);
 
         $failingRules = $validator->validateValuesForClass($class, [
@@ -154,7 +156,7 @@ public function test_nested_property_validation(): void
 
     public function test_nested_property_validation_with_dotted_keys(): void
     {
-        $validator = new Validator();
+        $validator = $this->validator;
 
         $class = new ClassReflector(ValidateObjectA::class);
 
@@ -178,7 +180,7 @@ public function test_nested_property_validation_with_dotted_keys(): void
 
     public function test_validation_infers_string_rule_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithStringProperty::class, ['prop' => (object) []]);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithStringProperty::class, ['prop' => (object) []]);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsString::class, $failingRules['prop'][0]);
@@ -186,7 +188,7 @@ public function test_validation_infers_string_rule_from_property_type(): void
 
     public function test_validation_infers_int_rule_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithIntProp::class, ['prop' => 'a']);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithIntProp::class, ['prop' => 'a']);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsInteger::class, $failingRules['prop'][0]);
@@ -194,7 +196,7 @@ public function test_validation_infers_int_rule_from_property_type(): void
 
     public function test_validation_infers_float_rule_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithFloatProp::class, ['prop' => 'a']);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithFloatProp::class, ['prop' => 'a']);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsFloat::class, $failingRules['prop'][0]);
@@ -202,7 +204,7 @@ public function test_validation_infers_float_rule_from_property_type(): void
 
     public function test_validation_infers_bool_rule_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithBoolProp::class, ['prop' => 'a']);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithBoolProp::class, ['prop' => 'a']);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsBoolean::class, $failingRules['prop'][0]);
@@ -210,7 +212,7 @@ public function test_validation_infers_bool_rule_from_property_type(): void
 
     public function test_validation_infers_enum_rule_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithEnumProp::class, ['prop' => 'a']);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithEnumProp::class, ['prop' => 'a']);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsEnum::class, $failingRules['prop'][0]);
@@ -218,7 +220,7 @@ public function test_validation_infers_enum_rule_from_property_type(): void
 
     public function test_validation_infers_not_null_from_scalar_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithStringProperty::class, ['prop' => null]);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithStringProperty::class, ['prop' => null]);
 
         $this->assertCount(1, $failingRules['prop']);
         $this->assertInstanceOf(IsString::class, $failingRules['prop'][0]);
@@ -226,50 +228,50 @@ public function test_validation_infers_not_null_from_scalar_property_type(): voi
 
     public function test_validation_infers_not_null_from_property_type(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithObjectProperty::class, ['prop' => null]);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithObjectProperty::class, ['prop' => null]);
 
         $this->assertCount(1, $failingRules['prop']);
-        $this->assertInstanceOf(NotNull::class, $failingRules['prop'][0]);
+        $this->assertInstanceOf(IsNotNull::class, $failingRules['prop'][0]);
     }
 
     public function test_skip_validation_attribute(): void
     {
-        $failingRules = new Validator()->validateValuesForClass(ObjectWithSkipValidation::class, []);
+        $failingRules = $this->validator->validateValuesForClass(ObjectWithSkipValidation::class, []);
 
         $this->assertEmpty($failingRules);
     }
 
     public function test_validate_values_some_invalid(): void
     {
-        $failingRules = new Validator()->validateValues(
+        $failingRules = $this->validator->validateValues(
             [
                 'name' => '',
                 'email' => 'invalid-email',
                 'age' => 0,
             ],
             [
-                'name' => [new IsString(), new NotNull()],
-                'email' => [new Email()],
-                'age' => [new IsInteger(), new NotNull()],
+                'name' => [new IsString(), new IsNotNull()],
+                'email' => [new IsEmail()],
+                'age' => [new IsInteger(), new IsNotNull()],
             ],
         );
 
         $this->assertCount(1, $failingRules);
-        $this->assertInstanceOf(Email::class, $failingRules['email'][0]);
+        $this->assertInstanceOf(IsEmail::class, $failingRules['email'][0]);
     }
 
     public function test_validate_values_all_valid(): void
     {
-        $failingRules = new Validator()->validateValues(
+        $failingRules = $this->validator->validateValues(
             [
                 'name' => '',
                 'email' => 'foo@bar.baz',
                 'age' => 0,
             ],
             [
-                'name' => [new IsString(), new NotNull()],
-                'email' => [new Email()],
-                'age' => [new IsInteger(), new NotNull()],
+                'name' => [new IsString(), new IsNotNull()],
+                'email' => [new IsEmail()],
+                'age' => [new IsInteger(), new IsNotNull()],
             ],
         );
 
diff --git a/packages/view/src/Components/x-input.view.php b/packages/view/src/Components/x-input.view.php
index 23615f2f2..f9bd1f971 100644
--- a/packages/view/src/Components/x-input.view.php
+++ b/packages/view/src/Components/x-input.view.php
@@ -8,6 +8,7 @@
  */
 
 use Tempest\Http\Session\Session;
+use Tempest\Validation\Validator;
 
 use function Tempest\get;
 use function Tempest\Support\str;
@@ -15,6 +16,9 @@
 /** @var Session $session */
 $session = get(Session::class);
 
+/** @var Validator $validator */
+$validator = get(Validator::class);
+
 $label ??= str($name)->title();
 $id ??= $name;
 $type ??= 'text';
@@ -30,9 +34,9 @@
     <textarea :if="$type === 'textarea'" :name="$name" :id="$id">{{ $original }}</textarea>
     <input :else :type="$type" :name="$name" :id="$id" :value="$original"/>
 
-    <div :if="$errors !== []">
-        <div :foreach="$errors as $error">
-            {{ $error->message() }}
-        </div>
-    </div>
+    <ul :if="$errors !== []">
+        <li :foreach="$errors as $error">
+            {{ $validator->getErrorMessage($error) }}
+        </li>
+    </ul>
 </div>
diff --git a/rector.php b/rector.php
index 3e383346f..9e7f93ca5 100644
--- a/rector.php
+++ b/rector.php
@@ -20,6 +20,7 @@
 use Rector\Php83\Rector\ClassMethod\AddOverrideAttributeToOverriddenMethodsRector;
 use Rector\Php84\Rector\Param\ExplicitNullableParamTypeRector;
 use Rector\Privatization\Rector\ClassMethod\PrivatizeFinalClassMethodRector;
+use Rector\Renaming\Rector\Name\RenameClassRector;
 use Rector\TypeDeclaration\Rector\ArrowFunction\AddArrowFunctionReturnTypeRector;
 use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;
 use Rector\TypeDeclaration\Rector\Closure\ClosureReturnTypeRector;
diff --git a/src/Tempest/Framework/Testing/Http/HttpRouterTester.php b/src/Tempest/Framework/Testing/Http/HttpRouterTester.php
index 005432494..c89a3f5c0 100644
--- a/src/Tempest/Framework/Testing/Http/HttpRouterTester.php
+++ b/src/Tempest/Framework/Testing/Http/HttpRouterTester.php
@@ -13,6 +13,7 @@
 use Tempest\Http\Request;
 use Tempest\Router\RouteConfig;
 use Tempest\Router\Router;
+use Tempest\Validation\Validator;
 
 use function Tempest\map;
 
@@ -140,7 +141,8 @@ public function sendRequest(Request $request): TestResponseHelper
         $this->container->get(RouteConfig::class)->throwHttpExceptions = $this->throwHttpExceptions;
 
         return new TestResponseHelper(
-            $router->dispatch(map($request)->with(RequestToPsrRequestMapper::class)->do()),
+            response: $router->dispatch(map($request)->with(RequestToPsrRequestMapper::class)->do()),
+            container: $this->container,
         );
     }
 
diff --git a/src/Tempest/Framework/Testing/Http/TestResponseHelper.php b/src/Tempest/Framework/Testing/Http/TestResponseHelper.php
index c15dd53c3..5a244b98a 100644
--- a/src/Tempest/Framework/Testing/Http/TestResponseHelper.php
+++ b/src/Tempest/Framework/Testing/Http/TestResponseHelper.php
@@ -9,6 +9,7 @@
 use JsonSerializable;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\ExpectationFailedException;
+use Tempest\Container\Container;
 use Tempest\Cryptography\Encryption\Encrypter;
 use Tempest\Http\Cookie\Cookie;
 use Tempest\Http\Response;
@@ -17,6 +18,7 @@
 use Tempest\Http\Status;
 use Tempest\Support\Arr;
 use Tempest\Validation\Rule;
+use Tempest\Validation\Validator;
 use Tempest\View\View;
 use Tempest\View\ViewRenderer;
 
@@ -27,6 +29,7 @@ final class TestResponseHelper
 {
     public function __construct(
         private(set) Response $response,
+        private(set) ?Container $container = null,
     ) {}
 
     public Status $status {
@@ -164,7 +167,7 @@ public function assertHasCookie(string $key, null|string|Closure $value = null):
             message: sprintf('No cookie was set for [%s], available cookies: %s', $key, implode(', ', array_keys($cookies))),
         );
 
-        $encrypter = get(Encrypter::class);
+        $encrypter = $this->container->get(Encrypter::class);
         $cookie = $cookies[$key]->value
             ? $encrypter->decrypt($cookies[$key]->value)
             : '';
@@ -182,14 +185,14 @@ public function assertHasCookie(string $key, null|string|Closure $value = null):
 
     public function assertHasSession(string $key, ?Closure $callback = null): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
+        $this->assertHasContainer();
 
+        $session = $this->container->get(Session::class);
         $data = $session->get($key);
 
         Assert::assertNotNull(
-            $data,
-            sprintf(
+            actual: $data,
+            message: sprintf(
                 'No session value was set for [%s], available session keys: %s',
                 $key,
                 implode(', ', array_keys($session->data)),
@@ -205,15 +208,13 @@ public function assertHasSession(string $key, ?Closure $callback = null): self
 
     public function assertHasValidationError(string $key, ?Closure $callback = null): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
-
+        $session = $this->container->get(Session::class);
         $validationErrors = $session->get(Session::VALIDATION_ERRORS) ?? [];
 
         Assert::assertArrayHasKey(
-            $key,
-            $validationErrors,
-            sprintf(
+            key: $key,
+            array: $validationErrors,
+            message: sprintf(
                 'No validation error was set for [%s], available validation errors: %s',
                 $key,
                 implode(', ', array_keys($validationErrors)),
@@ -229,23 +230,16 @@ public function assertHasValidationError(string $key, ?Closure $callback = null)
 
     public function assertHasNoValidationsErrors(): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
-
+        $session = $this->container->get(Session::class);
         $validationErrors = $session->get(Session::VALIDATION_ERRORS) ?? [];
 
         Assert::assertEmpty(
-            $validationErrors,
-            sprintf(
-                'There should be no validation errors, but there were: %s',
-                arr($validationErrors)
-                    ->map(function (array $failingRules, $key) {
-                        $failingRules = arr($failingRules)->map(fn (Rule $rule) => $rule->message())->implode(', ');
-
-                        return $key . ': ' . $failingRules;
-                    })
-                    ->implode(', '),
-            ),
+            actual: $validationErrors,
+            message: arr($validationErrors)
+                ->map(fn (array $failingRules, string $key) => $key . ': ' . arr($failingRules)->map(fn (Rule $rule) => $rule::class)->implode(', '))
+                ->implode(', ')
+                ->prepend('There should be no validation errors, but there were: ')
+                ->toString(),
         );
 
         return $this;
@@ -256,7 +250,7 @@ public function assertSee(string $search): self
         $body = $this->body;
 
         if ($body instanceof View) {
-            $body = get(ViewRenderer::class)->render($body);
+            $body = $this->container->get(ViewRenderer::class)->render($body);
         }
 
         Assert::assertStringContainsString($search, $body);
@@ -269,7 +263,7 @@ public function assertNotSee(string $search): self
         $body = $this->body;
 
         if ($body instanceof View) {
-            $body = get(ViewRenderer::class)->render($body);
+            $body = $this->container->get(ViewRenderer::class)->render($body);
         }
 
         Assert::assertStringNotContainsString($search, $body);
@@ -492,18 +486,21 @@ public function assertJsonContains(array $expected): self
      */
     public function assertHasJsonValidationErrors(array $expectedErrors): self
     {
+        $this->assertHasContainer();
+
         Assert::assertInstanceOf(Invalid::class, $this->response);
         Assert::assertContains($this->response->status, [Status::BAD_REQUEST, Status::FOUND]);
         Assert::assertNotNull($this->response->getHeader('x-validation'));
 
-        $session = get(Session::class);
+        $session = $this->container->get(Session::class);
+        $validator = $this->container->get(Validator::class);
         $validationRules = arr($session->get(Session::VALIDATION_ERRORS))->dot();
 
-        $dottedExpectedErrors = arr($expectedErrors)->dot();
-        arr($dottedExpectedErrors)
+        arr($expectedErrors)
+            ->dot()
             ->each(fn ($expectedErrorValue, $expectedErrorKey) => Assert::assertEquals(
-                $expectedErrorValue,
-                $validationRules->get($expectedErrorKey)->message(),
+                expected: $expectedErrorValue,
+                actual: $validator->getErrorMessage($validationRules->get($expectedErrorKey)),
             ));
 
         return $this;
@@ -535,4 +532,11 @@ public function dd(): void
          */
         dd($this->response); // @mago-expect best-practices/no-debug-symbols
     }
+
+    private function assertHasContainer(): void
+    {
+        if ($this->container === null) {
+            Assert::fail('This assertion requires a container.');
+        }
+    }
 }
diff --git a/tests/Fixtures/Modules/Books/Models/Book.php b/tests/Fixtures/Modules/Books/Models/Book.php
index 221e65f4a..187cdb790 100644
--- a/tests/Fixtures/Modules/Books/Models/Book.php
+++ b/tests/Fixtures/Modules/Books/Models/Book.php
@@ -7,13 +7,13 @@
 use Tempest\Database\HasOne;
 use Tempest\Database\IsDatabaseModel;
 use Tempest\Router\Bindable;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class Book implements Bindable
 {
     use IsDatabaseModel;
 
-    #[Length(min: 1, max: 120)]
+    #[HasLength(min: 1, max: 120)]
     public string $title;
 
     public ?Author $author = null;
diff --git a/tests/Fixtures/Modules/Books/Requests/StoreBookRequest.php b/tests/Fixtures/Modules/Books/Requests/StoreBookRequest.php
index 3c4031002..50e13bebf 100644
--- a/tests/Fixtures/Modules/Books/Requests/StoreBookRequest.php
+++ b/tests/Fixtures/Modules/Books/Requests/StoreBookRequest.php
@@ -4,10 +4,10 @@
 
 namespace Tests\Tempest\Fixtures\Modules\Books\Requests;
 
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class StoreBookRequest
 {
-    #[Length(min: 10, max: 120)]
+    #[HasLength(min: 10, max: 120)]
     public string $title;
 }
diff --git a/tests/Fixtures/Modules/Form/FormRequest.php b/tests/Fixtures/Modules/Form/FormRequest.php
index b380de8ac..c44b88e88 100644
--- a/tests/Fixtures/Modules/Form/FormRequest.php
+++ b/tests/Fixtures/Modules/Form/FormRequest.php
@@ -6,16 +6,16 @@
 
 use Tempest\Http\IsRequest;
 use Tempest\Http\Request;
-use Tempest\Validation\Rules\Between;
-use Tempest\Validation\Rules\NotEmpty;
+use Tempest\Validation\Rules\IsBetween;
+use Tempest\Validation\Rules\IsNotEmptyString;
 
 final class FormRequest implements Request
 {
     use IsRequest;
 
-    #[NotEmpty]
+    #[IsNotEmptyString]
     public string $name;
 
-    #[Between(min: 10, max: 15)]
+    #[IsBetween(min: 10, max: 15)]
     public int $number;
 }
diff --git a/tests/Fixtures/Requests/BookRequest.php b/tests/Fixtures/Requests/BookRequest.php
index a3fffd463..04ca40b0f 100644
--- a/tests/Fixtures/Requests/BookRequest.php
+++ b/tests/Fixtures/Requests/BookRequest.php
@@ -7,7 +7,7 @@
 use Tempest\Database\HasOne;
 use Tempest\Http\IsRequest;
 use Tempest\Http\Request;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 use Tests\Tempest\Fixtures\Modules\Books\Models\Author;
 use Tests\Tempest\Fixtures\Modules\Books\Models\Isbn;
 
@@ -15,7 +15,7 @@ final class BookRequest implements Request
 {
     use IsRequest;
 
-    #[Length(min: 1, max: 120)]
+    #[HasLength(min: 1, max: 120)]
     public string $title;
 
     public ?Author $author = null;
diff --git a/tests/Fixtures/Requests/ValidationRequest.php b/tests/Fixtures/Requests/ValidationRequest.php
index 6e7e1b647..a77d474b2 100644
--- a/tests/Fixtures/Requests/ValidationRequest.php
+++ b/tests/Fixtures/Requests/ValidationRequest.php
@@ -6,12 +6,12 @@
 
 use Tempest\Http\IsRequest;
 use Tempest\Http\Request;
-use Tempest\Validation\Rules\Between;
+use Tempest\Validation\Rules\IsBetween;
 
 final class ValidationRequest implements Request
 {
     use IsRequest;
 
-    #[Between(min: 1, max: 10)]
+    #[IsBetween(min: 1, max: 10)]
     public int $number;
 }
diff --git a/tests/Integration/Console/Fixtures/InteractiveCommand.php b/tests/Integration/Console/Fixtures/InteractiveCommand.php
index 13191964e..afa941cbb 100644
--- a/tests/Integration/Console/Fixtures/InteractiveCommand.php
+++ b/tests/Integration/Console/Fixtures/InteractiveCommand.php
@@ -7,9 +7,9 @@
 use Tempest\Console\Console;
 use Tempest\Console\ConsoleCommand;
 use Tempest\Console\HasConsole;
-use Tempest\Validation\Rules\Count;
-use Tempest\Validation\Rules\Email;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasCount;
+use Tempest\Validation\Rules\HasLength;
+use Tempest\Validation\Rules\IsEmail;
 
 final readonly class InteractiveCommand
 {
@@ -34,8 +34,8 @@ public function enum(): void
     #[ConsoleCommand('interactive:validation')]
     public function validation(): void
     {
-        $a = $this->console->ask('a', validation: [new Length(min: 2), new Length(max: 2)]);
-        $b = $this->console->ask('b', validation: [new Email()]);
+        $a = $this->console->ask('a', validation: [new HasLength(min: 2), new HasLength(max: 2)]);
+        $b = $this->console->ask('b', validation: [new IsEmail()]);
 
         $this->console->success("{$a} {$b}");
     }
@@ -110,7 +110,7 @@ public function multiple(): void
             question: 'Pick several',
             options: ['a', 'b', 'c'],
             multiple: true,
-            validation: [new Count(min: 1)],
+            validation: [new HasCount(min: 1)],
         );
 
         $result = json_encode($result);
diff --git a/tests/Integration/Database/MultiDatabaseTest.php b/tests/Integration/Database/MultiDatabaseTest.php
index 53bb69819..0f3aa6ca5 100644
--- a/tests/Integration/Database/MultiDatabaseTest.php
+++ b/tests/Integration/Database/MultiDatabaseTest.php
@@ -135,8 +135,10 @@ public function test_with_multiple_connections(): void
 
     public function test_with_different_dialects(): void
     {
+        $this->expectNotToPerformAssertions();
+
         if ($this->container->get(Database::class)->dialect !== DatabaseDialect::MYSQL) {
-            $this->markTestSkipped('We only test this in the MySQL test action');
+            return;
         }
 
         $this->container->config(new SQLiteConfig(
@@ -152,8 +154,6 @@ public function test_with_different_dialects(): void
 
         $migrationManager->onDatabase('sqlite-main')->executeUp(new CreateMigrationsTable());
         $migrationManager->onDatabase('mysql-main')->executeUp(new CreateMigrationsTable());
-
-        $this->expectNotToPerformAssertions();
     }
 
     public function test_fails_with_unknown_connection(): void
diff --git a/tests/Integration/Http/Responses/InvalidTest.php b/tests/Integration/Http/Responses/InvalidTest.php
index 800f93144..8608fa928 100644
--- a/tests/Integration/Http/Responses/InvalidTest.php
+++ b/tests/Integration/Http/Responses/InvalidTest.php
@@ -9,7 +9,7 @@
 use Tempest\Http\Responses\Invalid;
 use Tempest\Http\Session\Session;
 use Tempest\Http\Status;
-use Tempest\Validation\Rules\NotEmpty;
+use Tempest\Validation\Rules\IsNotEmptyString;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
 /**
@@ -25,7 +25,7 @@ public function test_invalid_with_psr_request(): void
             $request,
             [
                 'foo' => [
-                    new NotEmpty(),
+                    new IsNotEmptyString(),
                 ],
             ],
         );
@@ -52,7 +52,7 @@ public function test_invalid_with_request(): void
             $request,
             [
                 'foo' => [
-                    new NotEmpty(),
+                    new IsNotEmptyString(),
                 ],
             ],
         );
diff --git a/tests/Integration/Http/ValidationResponseTest.php b/tests/Integration/Http/ValidationResponseTest.php
index 9c75c822c..14e6d96a9 100644
--- a/tests/Integration/Http/ValidationResponseTest.php
+++ b/tests/Integration/Http/ValidationResponseTest.php
@@ -96,7 +96,7 @@ public function test_failing_post_request(): void
                 uri([ValidationController::class, 'updateBook'], book: 1),
                 body: ['book' => ['title' => 1]],
             )
-            ->assertHasJsonValidationErrors(['title' => ['Value should be between 1 and 120']]);
+            ->assertHasJsonValidationErrors(['title' => ['Value must be between 1 and 120']]);
 
         $this->assertSame('Timeline Taxi', Book::find(id: 1)->first()->title);
     }
diff --git a/tests/Integration/Intl/DiscoveryTest.php b/tests/Integration/Intl/DiscoveryTest.php
index aee57cfd6..29ff426fd 100644
--- a/tests/Integration/Intl/DiscoveryTest.php
+++ b/tests/Integration/Intl/DiscoveryTest.php
@@ -5,6 +5,7 @@
 use Tempest\Discovery\DiscoveryItems;
 use Tempest\Discovery\DiscoveryLocation;
 use Tempest\Intl\IntlConfig;
+use Tempest\Intl\Locale;
 use Tempest\Intl\TranslationMessageDiscovery;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
@@ -14,7 +15,7 @@ public function test_functions_are_discovered(): void
     {
         $config = $this->container->get(IntlConfig::class);
 
-        $this->assertCount(3, $config->functions);
+        $this->assertCount(4, $config->functions);
     }
 
     public function test_markup_formatters_are_discovered(): void
@@ -26,6 +27,11 @@ public function test_markup_formatters_are_discovered(): void
 
     public function test_discovery_adds_paths_to_config(): void
     {
+        $this->container->config(new IntlConfig(
+            currentLocale: Locale::default(),
+            fallbackLocale: Locale::default(),
+        ));
+
         $discovery = $this->container->get(TranslationMessageDiscovery::class);
         $discovery->setItems(new DiscoveryItems([]));
         $discovery->discoverPath(new DiscoveryLocation('', ''), __DIR__ . '/Fixtures/messages.json');
diff --git a/tests/Integration/Mapper/Fixtures/ObjectFactoryWithValidation.php b/tests/Integration/Mapper/Fixtures/ObjectFactoryWithValidation.php
index 1250eec8e..8041a66e1 100644
--- a/tests/Integration/Mapper/Fixtures/ObjectFactoryWithValidation.php
+++ b/tests/Integration/Mapper/Fixtures/ObjectFactoryWithValidation.php
@@ -5,12 +5,12 @@
 namespace Tests\Tempest\Integration\Mapper\Fixtures;
 
 use Tempest\Database\IsDatabaseModel;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Rules\HasLength;
 
 final class ObjectFactoryWithValidation
 {
     use IsDatabaseModel;
 
-    #[Length(min: 2)]
+    #[HasLength(min: 2)]
     public string $prop;
 }
diff --git a/tests/Integration/Mapper/Fixtures/ObjectThatShouldUseCasters.php b/tests/Integration/Mapper/Fixtures/ObjectThatShouldUseCasters.php
index d41635e48..dcdd94a40 100644
--- a/tests/Integration/Mapper/Fixtures/ObjectThatShouldUseCasters.php
+++ b/tests/Integration/Mapper/Fixtures/ObjectThatShouldUseCasters.php
@@ -6,15 +6,15 @@
 
 use DateTimeImmutable;
 use Tempest\DateTime\DateTime;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final readonly class ObjectThatShouldUseCasters
 {
     public function __construct(
         public string $name,
-        #[DateTimeFormat('Y-m-d')]
+        #[HasDateTimeFormat('Y-m-d')]
         public DateTimeImmutable $nativeDate,
-        #[DateTimeFormat('yyyy-MM-dd')]
+        #[HasDateTimeFormat('yyyy-MM-dd')]
         public DateTime $date,
         public EnumToCast $enum,
     ) {}
diff --git a/tests/Integration/Mapper/Fixtures/ObjectWithBuiltInCasters.php b/tests/Integration/Mapper/Fixtures/ObjectWithBuiltInCasters.php
index 3a40774de..e5cc2c41d 100644
--- a/tests/Integration/Mapper/Fixtures/ObjectWithBuiltInCasters.php
+++ b/tests/Integration/Mapper/Fixtures/ObjectWithBuiltInCasters.php
@@ -6,7 +6,7 @@
 
 use DateTime;
 use DateTimeImmutable;
-use Tempest\Validation\Rules\DateTimeFormat;
+use Tempest\Validation\Rules\HasDateTimeFormat;
 
 final class ObjectWithBuiltInCasters
 {
@@ -18,7 +18,7 @@ final class ObjectWithBuiltInCasters
 
     public DateTime $dateTime;
 
-    #[DateTimeFormat('d/m/Y H:i:s')]
+    #[HasDateTimeFormat('d/m/Y H:i:s')]
     public DateTime $dateTimeWithFormat;
 
     public bool $bool;
diff --git a/tests/Integration/Mapper/PsrRequestToRequestMapperTest.php b/tests/Integration/Mapper/PsrRequestToRequestMapperTest.php
index 37bd7fd3c..cd2dcc27b 100644
--- a/tests/Integration/Mapper/PsrRequestToRequestMapperTest.php
+++ b/tests/Integration/Mapper/PsrRequestToRequestMapperTest.php
@@ -109,8 +109,6 @@ public function test_body_field_in_body(): void
             to: GenericRequest::class,
         );
 
-        $this->assertSame([
-            'body' => 'text',
-        ], $request->body);
+        $this->assertSame(['body' => 'text'], $request->body);
     }
 }
diff --git a/tests/Integration/ORM/IsDatabaseModelTest.php b/tests/Integration/ORM/IsDatabaseModelTest.php
index 4b16a818a..b4852c732 100644
--- a/tests/Integration/ORM/IsDatabaseModelTest.php
+++ b/tests/Integration/ORM/IsDatabaseModelTest.php
@@ -14,7 +14,9 @@
 use Tempest\DateTime\DateTime;
 use Tempest\Mapper\CasterFactory;
 use Tempest\Mapper\SerializerFactory;
+use Tempest\Support\Arr;
 use Tempest\Validation\Exceptions\ValidationFailed;
+use Tempest\Validation\Rules\IsBetween;
 use Tests\Tempest\Fixtures\Migrations\CreateAuthorTable;
 use Tests\Tempest\Fixtures\Migrations\CreateBookTable;
 use Tests\Tempest\Fixtures\Migrations\CreateChapterTable;
@@ -611,9 +613,10 @@ public function test_skipped_validation(): void
                 skip: -1,
             );
         } catch (ValidationFailed $validationFailed) {
-            $this->assertStringContainsString('index', $validationFailed->getMessage());
             $this->assertStringContainsString(ModelWithValidation::class, $validationFailed->getMessage());
-            $this->assertStringNotContainsString('skip', $validationFailed->getMessage());
+            $this->assertStringContainsString(ModelWithValidation::class, $validationFailed->subject);
+            $this->assertStringContainsString('index', array_key_first($validationFailed->failingRules));
+            $this->assertInstanceOf(IsBetween::class, Arr\first($validationFailed->failingRules)[0]);
         }
     }
 
diff --git a/tests/Integration/ORM/Models/ModelWithValidation.php b/tests/Integration/ORM/Models/ModelWithValidation.php
index 4152b1205..a174368bc 100644
--- a/tests/Integration/ORM/Models/ModelWithValidation.php
+++ b/tests/Integration/ORM/Models/ModelWithValidation.php
@@ -3,14 +3,14 @@
 namespace Tests\Tempest\Integration\ORM\Models;
 
 use Tempest\Database\IsDatabaseModel;
-use Tempest\Validation\Rules\Between;
+use Tempest\Validation\Rules\IsBetween;
 use Tempest\Validation\SkipValidation;
 
 final class ModelWithValidation
 {
     use IsDatabaseModel;
 
-    #[Between(min: 1, max: 10)]
+    #[IsBetween(min: 1, max: 10)]
     public int $index;
 
     #[SkipValidation]
diff --git a/tests/Integration/Route/RequestToObjectMapperTest.php b/tests/Integration/Route/RequestToObjectMapperTest.php
index 554811d11..739bd89f6 100644
--- a/tests/Integration/Route/RequestToObjectMapperTest.php
+++ b/tests/Integration/Route/RequestToObjectMapperTest.php
@@ -10,7 +10,7 @@
 use Tempest\Http\RequestParametersIncludedReservedNames;
 use Tempest\Http\Upload;
 use Tempest\Validation\Exceptions\ValidationFailed;
-use Tempest\Validation\Rules\NotNull;
+use Tempest\Validation\Rules\IsNotNull;
 use Tests\Tempest\Fixtures\Modules\Books\Requests\CreateBookRequest;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 use Tests\Tempest\Integration\Route\Fixtures\EnumForRequest;
@@ -30,7 +30,7 @@ public function test_request(): void
         try {
             map($request)->to(RequestObjectA::class);
         } catch (ValidationFailed $validationFailed) {
-            $this->assertInstanceOf(NotNull::class, $validationFailed->failingRules['b'][0]);
+            $this->assertInstanceOf(IsNotNull::class, $validationFailed->failingRules['b'][0]);
         }
     }
 
diff --git a/tests/Integration/Validator/BackedEnumFixture.php b/tests/Integration/Validator/BackedEnumFixture.php
new file mode 100644
index 000000000..0c6a5712b
--- /dev/null
+++ b/tests/Integration/Validator/BackedEnumFixture.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Tests\Tempest\Integration\Validator;
+
+enum BackedEnumFixture: string
+{
+    case FOO = 'foo';
+    case BAR = 'bar';
+    case BAZ = 'baz';
+}
diff --git a/tests/Integration/Validator/TranslationsTest.php b/tests/Integration/Validator/TranslationsTest.php
new file mode 100644
index 000000000..d4d6b06d1
--- /dev/null
+++ b/tests/Integration/Validator/TranslationsTest.php
@@ -0,0 +1,709 @@
+<?php
+
+namespace Tests\Tempest\Integration\Validator;
+
+use PHPUnit\Framework\Attributes\TestWith;
+use Tempest\DateTime\FormatPattern;
+use Tempest\Validation\Rule;
+use Tempest\Validation\Rules;
+use Tempest\Validation\Validator;
+use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
+
+final class TranslationsTest extends FrameworkIntegrationTestCase
+{
+    private function translate(Rule $rule, ?string $field = null): string
+    {
+        return $this->container
+            ->get(Validator::class)
+            ->getErrorMessage($rule, $field);
+    }
+
+    private function formatWithField(string $message, ?string $field, string $expected = 'Value'): string
+    {
+        return sprintf($message, $field ?? $expected);
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Creation date'])]
+    public function test_after_date(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be after or equal to January 1, 2024', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsAfterDate(date: '2024-01-01', inclusive: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be after January 1, 2024', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsAfterDate(date: '2024-01-01', inclusive: false), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Creation date'])]
+    public function test_before_date(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a date before or equal to January 1, 2024', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsBeforeDate(date: '2024-01-01', inclusive: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a date before January 1, 2024', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsBeforeDate(date: '2024-01-01', inclusive: false), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Creation date'])]
+    public function test_between_dates(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a date between January 1, 2024 and January 1, 2025, included', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsBetweenDates(first: '2024-01-01', second: '2025-01-01', inclusive: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a date between January 1, 2024 and January 1, 2025', $field, expected: 'Date'),
+            actual: $this->translate(new Rules\IsBetweenDates(first: '2024-01-01', second: '2025-01-01'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_alpha(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain only alphabetic characters', $field),
+            actual: $this->translate(new Rules\IsAlpha(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_alpha_numeric(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain only alphanumeric characters', $field),
+            actual: $this->translate(new Rules\IsAlphaNumeric(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_array_list(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a list', $field),
+            actual: $this->translate(new Rules\IsArrayList(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_between(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be between 0 and 2', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsBetween(min: 0, max: 2), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be between 2 and 4', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsBetween(min: 2, max: 4), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Array'])]
+    public function test_count(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must have at least 3 items', $field),
+            actual: $this->translate(new Rules\HasCount(min: 3), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must have at least 0 items', $field),
+            actual: $this->translate(new Rules\HasCount(min: 0), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must have at most 10 items', $field),
+            actual: $this->translate(new Rules\HasCount(max: 10), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must have between 3 and 10 items', $field),
+            actual: $this->translate(new Rules\HasCount(min: 3, max: 10), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must have between 0 and 2 items', $field),
+            actual: $this->translate(new Rules\HasCount(min: 0, max: 2), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_date_time_format(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must use the format yyyy-MM-dd', $field),
+            actual: $this->translate(new Rules\HasDateTimeFormat('yyyy-MM-dd'), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must use the format MM/dd/yyyy', $field),
+            actual: $this->translate(new Rules\HasDateTimeFormat(FormatPattern::AMERICAN), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_divisible_by(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be divisible by 1', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsDivisibleBy(divisor: 1), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_does_not_end_with(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not end with "foo"', $field),
+            actual: $this->translate(new Rules\DoesNotEndWith(needle: 'foo'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_email(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid email address', $field, expected: 'Email'),
+            actual: $this->translate(new Rules\IsEmail(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_does_not_start_with(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not start with "foo"', $field),
+            actual: $this->translate(new Rules\DoesNotStartWith(needle: 'foo'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_ends_with(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must end with "foo"', $field),
+            actual: $this->translate(new Rules\EndsWith(needle: 'foo'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_even(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be even', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsEvenNumber(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_hex_color(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a hexadecimal color', $field),
+            actual: $this->translate(new Rules\IsHexColor(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_in(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a', $field),
+            actual: $this->translate(new Rules\IsIn(['a']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a or b', $field),
+            actual: $this->translate(new Rules\IsIn(['a', 'b']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a, b or c', $field),
+            actual: $this->translate(new Rules\IsIn(['a', 'b', 'c']), field: $field),
+        );
+    }
+
+    #[TestWith(['IP', null])]
+    #[TestWith(['IP', 'Input'])]
+    #[TestWith(['IPv4', null])]
+    #[TestWith(['IPv4', 'Input'])]
+    #[TestWith(['IPv6', null])]
+    #[TestWith(['IPv6', 'Input'])]
+    public function test_ip(string $ip, ?string $field = null): void
+    {
+        $class = match ($ip) {
+            'IPv4' => Rules\IsIPv4::class,
+            'IPv6' => Rules\IsIPv6::class,
+            default => Rules\IsIP::class,
+        };
+
+        $this->assertSame(
+            expected: $this->formatWithField("%s must be a valid {$ip} address", $field),
+            actual: $this->translate(new $class(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField("%s must be a valid {$ip} address, not in a reserved range", $field),
+            actual: $this->translate(new $class(allowReservedRange: false), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField("%s must be a valid {$ip} address, not in a private range", $field),
+            actual: $this->translate(new $class(allowPrivateRange: false), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField("%s must be a valid {$ip} address, not in a private or reserved range", $field),
+            actual: $this->translate(new $class(allowPrivateRange: false, allowReservedRange: false), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_boolean(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a boolean', $field),
+            actual: $this->translate(new Rules\IsBoolean(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a boolean if specified', $field),
+            actual: $this->translate(new Rules\IsBoolean(orNull: true), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_enum(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be FOO, BAR or BAZ', $field),
+            actual: $this->translate(new Rules\IsEnum(UnitEnumFixture::class), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be FOO or BAZ', $field),
+            actual: $this->translate(new Rules\IsEnum(UnitEnumFixture::class, except: [UnitEnumFixture::BAR]), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be foo, bar or baz', $field),
+            actual: $this->translate(new Rules\IsEnum(BackedEnumFixture::class), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be foo or baz', $field),
+            actual: $this->translate(new Rules\IsEnum(BackedEnumFixture::class, except: [BackedEnumFixture::BAR]), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_float(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a floating point number', $field),
+            actual: $this->translate(new Rules\IsFloat(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a floating point number if specified', $field),
+            actual: $this->translate(new Rules\IsFloat(orNull: true), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_integer(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a number', $field),
+            actual: $this->translate(new Rules\IsInteger(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a number if specified', $field),
+            actual: $this->translate(new Rules\IsInteger(orNull: true), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_string(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a string', $field),
+            actual: $this->translate(new Rules\IsString(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a string or be empty', $field),
+            actual: $this->translate(new Rules\IsString(orNull: true), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_is_json(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid JSON string', $field),
+            actual: $this->translate(new Rules\IsJsonString(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_length(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be at least 0', $field),
+            actual: $this->translate(new Rules\HasLength(min: 0), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be at most 0', $field),
+            actual: $this->translate(new Rules\HasLength(max: 0), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be between 0 and 2', $field),
+            actual: $this->translate(new Rules\HasLength(min: 0, max: 2), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_lowercase(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a lowercase string', $field),
+            actual: $this->translate(new Rules\IsLowercase(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_mac_address(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid MAC address', $field),
+            actual: $this->translate(new Rules\IsMacAddress(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_multiple_of(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a multiple of 5', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsMultipleOf(divisor: 5), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_not_empty(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not be empty', $field),
+            actual: $this->translate(new Rules\IsNotEmptyString(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_not_in(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not be a', $field),
+            actual: $this->translate(new Rules\IsNotIn(['a']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not be a or b', $field),
+            actual: $this->translate(new Rules\IsNotIn(['a', 'b']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must not be a, b or c', $field),
+            actual: $this->translate(new Rules\IsNotIn(['a', 'b', 'c']), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_not_null(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be specified', $field),
+            actual: $this->translate(new Rules\IsNotNull(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_numeric(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be numeric', $field),
+            actual: $this->translate(new Rules\IsNumeric(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_odd(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be odd', $field, expected: 'Number'),
+            actual: $this->translate(new Rules\IsOddNumber(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_password(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 4 characters', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(min: 4), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one uppercase and one lowercase letter', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(mixedCase: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters and one number', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(numbers: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters and one symbol', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters and one letter', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(letters: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField(
+                '%s must contain at least 12 characters, one uppercase and one lowercase letter, one number, and one symbol',
+                $field,
+                expected: 'Password',
+            ),
+            actual: $this->translate(new Rules\IsPassword(mixedCase: true, numbers: true, symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one uppercase and one lowercase letter, and one number', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(mixedCase: true, numbers: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one uppercase and one lowercase letter, and one symbol', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(mixedCase: true, symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one number, one letter and one symbol', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(letters: true, numbers: true, symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one number and one letter', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(letters: true, numbers: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one letter and one symbol', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(letters: true, symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one number and one symbol', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(numbers: true, symbols: true), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must contain at least 12 characters, one number and one letter', $field, expected: 'Password'),
+            actual: $this->translate(new Rules\IsPassword(letters: true, numbers: true), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_phone_number(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a phone number', $field),
+            actual: $this->translate(new Rules\IsPhoneNumber(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_regex(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must match the pattern /[A-Z]/', $field),
+            actual: $this->translate(new Rules\MatchesRegEx('/[A-Z]/'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_should_be_false(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be false', $field),
+            actual: $this->translate(new Rules\IsFalsy(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_should_be_true(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be true', $field),
+            actual: $this->translate(new Rules\IsTruthy(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_starts_with(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must start with foo', $field),
+            actual: $this->translate(new Rules\StartsWith('foo'), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_time(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid time in 24-hour format', $field),
+            actual: $this->translate(new Rules\IsTime(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid time in 12-hour format', $field),
+            actual: $this->translate(new Rules\IsTime(false), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_timestamp(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid timestamp', $field),
+            actual: $this->translate(new Rules\IsUnixTimestamp(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_timezone(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid timezone', $field),
+            actual: $this->translate(new Rules\IsTimezone(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_ulid(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a lexicographically sortable identifier', $field),
+            actual: $this->translate(new Rules\IsUlid(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_uppercase(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be an uppercase string', $field),
+            actual: $this->translate(new Rules\IsUppercase(), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_url(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a valid URL', $field),
+            actual: $this->translate(new Rules\IsUrl(), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a URL using https', $field),
+            actual: $this->translate(new Rules\IsUrl(['https']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a URL using https or http', $field),
+            actual: $this->translate(new Rules\IsUrl(['https', 'http']), field: $field),
+        );
+
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a URL using ftp, https or http', $field),
+            actual: $this->translate(new Rules\IsUrl(['ftp', 'https', 'http']), field: $field),
+        );
+    }
+
+    #[TestWith([null])]
+    #[TestWith(['Input'])]
+    public function test_uuid(?string $field = null): void
+    {
+        $this->assertSame(
+            expected: $this->formatWithField('%s must be a universally unique identifier', $field),
+            actual: $this->translate(new Rules\IsUuid(), field: $field),
+        );
+    }
+}
diff --git a/tests/Integration/Validator/UnitEnumFixture.php b/tests/Integration/Validator/UnitEnumFixture.php
new file mode 100644
index 000000000..d532a5719
--- /dev/null
+++ b/tests/Integration/Validator/UnitEnumFixture.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Tests\Tempest\Integration\Validator;
+
+enum UnitEnumFixture
+{
+    case FOO;
+    case BAR;
+    case BAZ;
+}
diff --git a/tests/Integration/View/Components/InputComponentTest.php b/tests/Integration/View/Components/InputComponentTest.php
index aa0070c89..5d448efa8 100644
--- a/tests/Integration/View/Components/InputComponentTest.php
+++ b/tests/Integration/View/Components/InputComponentTest.php
@@ -3,9 +3,10 @@
 namespace Integration\View\Components;
 
 use Tempest\Http\Session\Session;
+use Tempest\Validation\Rules\HasLength;
 use Tempest\Validation\Rules\IsInteger;
 use Tempest\Validation\Rules\IsString;
-use Tempest\Validation\Rules\Length;
+use Tempest\Validation\Validator;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
 final class InputComponentTest extends FrameworkIntegrationTestCase
@@ -77,7 +78,7 @@ public function test_error_message(): void
         $failingRules = [
             'name' => [
                 new IsString(),
-                new Length(min: 5),
+                new HasLength(min: 5),
             ],
             'other' => [
                 new IsInteger(),
@@ -88,8 +89,10 @@ public function test_error_message(): void
 
         $html = $this->render('<x-input name="name" />');
 
-        $this->assertStringContainsString(new IsString()->message(), $html);
-        $this->assertStringContainsString(new Length(min: 5)->message(), $html);
-        $this->assertStringNotContainsString(new IsInteger()->message(), $html);
+        $validator = $this->container->get(Validator::class);
+
+        $this->assertStringContainsString($validator->getErrorMessage(new IsString()), $html);
+        $this->assertStringContainsString($validator->getErrorMessage(new HasLength(min: 5)), $html);
+        $this->assertStringNotContainsString($validator->getErrorMessage(new IsInteger()), $html);
     }
 }
diff --git a/tests/Integration/View/ViewComponentTest.php b/tests/Integration/View/ViewComponentTest.php
index b6c61e8de..c8c1cb599 100644
--- a/tests/Integration/View/ViewComponentTest.php
+++ b/tests/Integration/View/ViewComponentTest.php
@@ -9,8 +9,9 @@
 use Tempest\Core\AppConfig;
 use Tempest\Core\Environment;
 use Tempest\Http\Session\Session;
-use Tempest\Validation\Rules\AlphaNumeric;
-use Tempest\Validation\Rules\Between;
+use Tempest\Validation\Rules\IsAlphaNumeric;
+use Tempest\Validation\Rules\IsBetween;
+use Tempest\Validation\Validator;
 use Tempest\View\Exceptions\DataAttributeWasInvalid;
 use Tempest\View\Exceptions\ViewVariableWasReserved;
 use Tempest\View\ViewCache;
@@ -214,8 +215,8 @@ public function test_component_with_anther_component_included_with_slot(): void
 
     public function test_view_component_with_injected_view(): void
     {
-        $between = new Between(min: 1, max: 10);
-        $alphaNumeric = new AlphaNumeric();
+        $between = new IsBetween(min: 1, max: 10);
+        $alphaNumeric = new IsAlphaNumeric();
 
         $session = $this->container->get(Session::class);
 
@@ -235,9 +236,11 @@ public function test_view_component_with_injected_view(): void
             HTML,
         ));
 
+        $validator = $this->container->get(Validator::class);
+
         $this->assertStringContainsString('value="original name"', $html);
-        $this->assertStringContainsString($between->message(), $html);
-        $this->assertStringContainsString($alphaNumeric->message(), $html);
+        $this->assertStringContainsString($validator->getErrorMessage($between), $html);
+        $this->assertStringContainsString($validator->getErrorMessage($alphaNumeric), $html);
     }
 
     public function test_component_with_if(): void