diff --git a/bin/create-mixin b/bin/create-mixin
new file mode 100755
index 00000000..4fe50701
--- /dev/null
+++ b/bin/create-mixin
@@ -0,0 +1,226 @@
+#!/usr/bin/env php
+<?php
+
+declare(strict_types=1);
+
+require __DIR__ . '/../vendor/autoload.php';
+
+use Nette\PhpGenerator\InterfaceType;
+use Nette\PhpGenerator\PhpNamespace;
+use Nette\PhpGenerator\Printer;
+use Respect\Validation\Mixins\ChainedKey;
+use Respect\Validation\Mixins\ChainedLength;
+use Respect\Validation\Mixins\ChainedMax;
+use Respect\Validation\Mixins\ChainedMin;
+use Respect\Validation\Mixins\ChainedNot;
+use Respect\Validation\Mixins\ChainedNullOr;
+use Respect\Validation\Mixins\ChainedProperty;
+use Respect\Validation\Mixins\ChainedUndefOr;
+use Respect\Validation\Mixins\ChainedValidator;
+use Respect\Validation\Mixins\StaticKey;
+use Respect\Validation\Mixins\StaticLength;
+use Respect\Validation\Mixins\StaticMax;
+use Respect\Validation\Mixins\StaticMin;
+use Respect\Validation\Mixins\StaticNot;
+use Respect\Validation\Mixins\StaticNullOr;
+use Respect\Validation\Mixins\StaticProperty;
+use Respect\Validation\Mixins\StaticUndefOr;
+use Respect\Validation\Validatable;
+
+function addMethodToInterface(
+    InterfaceType $interfaceType,
+    ReflectionClass $reflection,
+    ?string $prefix,
+    array $allowList,
+    array $denyList,
+): void {
+    if ($allowList !== [] && !in_array($reflection->getShortName(), $allowList, true)) {
+        return;
+    }
+
+    if ($denyList !== [] && in_array($reflection->getShortName(), $denyList, true)) {
+        return;
+    }
+
+    $name = $prefix ? $prefix . ucfirst($reflection->getShortName()) : lcfirst($reflection->getShortName());
+    $method = $interfaceType->addMethod($name)->setPublic()->setReturnType(ChainedValidator::class);
+    if (str_starts_with($interfaceType->getName(), 'Static')) {
+        $method->setStatic();
+    }
+
+    if ($prefix === 'key') {
+        $method->addParameter('key')->setType('int|string');
+    }
+
+    if ($prefix === 'property') {
+        $method->addParameter('propertyName')->setType('string');
+    }
+
+    $reflrectionConstructor = $reflection->getConstructor();
+    if ($reflrectionConstructor === null) {
+        return;
+    }
+    $commend = $reflrectionConstructor->getDocComment();
+    if ($commend) {
+        $method->addComment(preg_replace('@(/\*\* *| +\* +| +\*/)@', '', $commend));
+    }
+
+    foreach ($reflrectionConstructor->getParameters() as $reflectionParameter) {
+        if ($reflectionParameter->isVariadic()) {
+            $method->setVariadic();
+        }
+
+        $type = $reflectionParameter->getType();
+        $types = [];
+        if ($type instanceof ReflectionUnionType) {
+            foreach ($type->getTypes() as $type) {
+                $types[] = $type->getName();
+            }
+        } elseif ($type instanceof ReflectionNamedType) {
+            $types[] = $type->getName();
+            if (            str_starts_with($type->getName(), 'Sokil')
+                || str_starts_with($type->getName(), 'Egulias')
+                || $type->getName() === 'finfo'
+            ) {
+                continue;
+            }
+        }
+        $parameter = $method->addParameter($reflectionParameter->getName());
+        $parameter->setType(implode('|', $types));
+
+        if (!$reflectionParameter->isDefaultValueAvailable()) {
+            $parameter->setNullable($reflectionParameter->isOptional());
+        }
+
+        if (count($types) > 1 || $reflectionParameter->isVariadic()) {
+            $parameter->setNullable(false);
+        }
+
+        if (!$reflectionParameter->isDefaultValueAvailable()) {
+            continue;
+        }
+
+        $defaultValue = $reflectionParameter->getDefaultValue();
+        if (is_object($defaultValue)) {
+            continue;
+        }
+
+        $parameter->setDefaultValue($reflectionParameter->getDefaultValue());
+        $parameter->setNullable(false);
+    }
+}
+
+function overwriteFile(string $content, string $basename): void
+{
+    file_put_contents(sprintf('%s/../library/Mixins/%s.php', __DIR__, $basename), implode(PHP_EOL . PHP_EOL, [
+        '<?php',
+        file_get_contents(__DIR__.'/../.docheader'),
+        'declare(strict_types=1);',
+        preg_replace('/extends (.+, )+/', 'extends' . PHP_EOL . '\1', $content),
+    ]));
+}
+
+(static function (): void {
+    $numberRelatedRules = [
+        'Between',
+        'BetweenExclusive',
+        'Equals',
+        'Equivalent',
+        'Even',
+        'Factor',
+        'Fibonacci',
+        'Finite',
+        'GreaterThan',
+        'Identical',
+        'In',
+        'Infinite',
+        'LessThan',
+        'LessThanOrEqual',
+        'GreaterThanOrEqual',
+        'Multiple',
+        'Odd',
+        'PerfectSquare',
+        'Positive',
+        'PrimeNumber',
+    ];
+
+    $structureRelatedRules = [
+        'Exists',
+        'Key',
+        'KeyExists',
+        'KeyOptional',
+        'KeySet',
+        'Property',
+        'PropertyExists',
+        'PropertyOptional',
+    ];
+
+    $mixins = [
+        ['Key', 'key', [], $structureRelatedRules],
+        ['Length', 'length', $numberRelatedRules, []],
+        ['Max', 'max', $numberRelatedRules, []],
+        ['Min', 'min', $numberRelatedRules, []],
+        ['Not', 'not', [], ['Not', 'NotEmpty', 'NotBlank', 'NotEmoji', 'NotOptional', 'Optional']],
+        ['NullOr', 'nullOf', [], ['Nullable', 'Optional']],
+        ['Property', 'property', [], $structureRelatedRules],
+        ['UndefOr', 'undefOf', [], ['Nullable', 'Optional']],
+        ['Validator', null, [], []],
+    ];
+
+    $names = [];
+    foreach (new DirectoryIterator(__DIR__ . '/../library/Rules') as $file) {
+        if (!$file->isFile()) {
+            continue;
+        }
+
+        $className = 'Respect\\Validation\\Rules\\' . $file->getBasename('.php');
+        $reflection = new ReflectionClass($className);
+        if ($reflection->isAbstract()) {
+            continue;
+        }
+        $names[$reflection->getShortName()] = $reflection;
+    }
+    ksort($names);
+
+    foreach ($mixins as [$name, $prefix, $allowList, $denyList]) {
+        $chainedNamespace = new PhpNamespace('Respect\\Validation\\Mixins');
+        $chainedNamespace->addUse(Validatable::class);
+        $chainedInterface = $chainedNamespace->addInterface('Chained' . $name);
+
+        $staticNamespace = new PhpNamespace('Respect\\Validation\\Mixins');
+        $staticNamespace->addUse(Validatable::class);
+        $staticInterface = $staticNamespace->addInterface('Static' . $name);
+
+        if ($name === 'Validator') {
+            $chainedInterface->addExtend(Validatable::class);
+            $chainedInterface->addExtend(ChainedKey::class);
+            $chainedInterface->addExtend(ChainedLength::class);
+            $chainedInterface->addExtend(ChainedMax::class);
+            $chainedInterface->addExtend(ChainedMin::class);
+            $chainedInterface->addExtend(ChainedNot::class);
+            $chainedInterface->addExtend(ChainedNullOr::class);
+            $chainedInterface->addExtend(ChainedProperty::class);
+            $chainedInterface->addExtend(ChainedUndefOr::class);
+
+            $staticInterface->addExtend(StaticKey::class);
+            $staticInterface->addExtend(StaticLength::class);
+            $staticInterface->addExtend(StaticMax::class);
+            $staticInterface->addExtend(StaticMin::class);
+            $staticInterface->addExtend(StaticNot::class);
+            $staticInterface->addExtend(StaticNullOr::class);
+            $staticInterface->addExtend(StaticProperty::class);
+            $staticInterface->addExtend(StaticUndefOr::class);
+        }
+
+        foreach ($names as $reflection) {
+            addMethodToInterface($staticInterface, $reflection, $prefix, $allowList, $denyList);
+            addMethodToInterface($chainedInterface, $reflection, $prefix, $allowList, $denyList);
+        }
+
+        $printer = new Printer();
+        $printer->wrapLength = 117;
+
+        overwriteFile($printer->printNamespace($staticNamespace), $staticInterface->getName());
+        overwriteFile($printer->printNamespace($chainedNamespace), $chainedInterface->getName());
+    }
+})();
diff --git a/composer.json b/composer.json
index e459a3fa..3a371908 100644
--- a/composer.json
+++ b/composer.json
@@ -27,6 +27,7 @@
         "giggsey/libphonenumber-for-php-lite": "^8.13",
         "malukenho/docheader": "^1.0",
         "mikey179/vfsstream": "^1.6",
+        "nette/php-generator": "^4.1",
         "phpstan/phpstan": "^1.10",
         "phpstan/phpstan-deprecation-rules": "^1.1",
         "phpstan/phpstan-phpunit": "^1.3",
diff --git a/library/Factory.php b/library/Factory.php
index b69660da..42145071 100644
--- a/library/Factory.php
+++ b/library/Factory.php
@@ -28,9 +28,11 @@ use Respect\Validation\Transformers\DeprecatedKeyValue;
 use Respect\Validation\Transformers\DeprecatedLength;
 use Respect\Validation\Transformers\DeprecatedMinAndMax;
 use Respect\Validation\Transformers\DeprecatedType;
+use Respect\Validation\Transformers\Prefix;
 use Respect\Validation\Transformers\RuleSpec;
 use Respect\Validation\Transformers\Transformer;
 
+use function array_merge;
 use function lcfirst;
 use function sprintf;
 use function trim;
@@ -65,7 +67,7 @@ final class Factory
             new DeprecatedKey(
                 new DeprecatedKeyValue(
                     new DeprecatedMinAndMax(
-                        new DeprecatedKeyNested(new DeprecatedLength(new DeprecatedType()))
+                        new DeprecatedKeyNested(new DeprecatedLength(new DeprecatedType(new Prefix())))
                     )
                 )
             )
@@ -121,23 +123,7 @@ final class Factory
      */
     public function rule(string $ruleName, array $arguments = []): Validatable
     {
-        $ruleSpec = $this->transformer->transform(new RuleSpec($ruleName, $arguments));
-        foreach ($this->rulesNamespaces as $namespace) {
-            try {
-                /** @var class-string<Validatable> $name */
-                $name = $namespace . '\\' . ucfirst($ruleSpec->name);
-                /** @var Validatable $rule */
-                $rule = $this
-                    ->createReflectionClass($name, Validatable::class)
-                    ->newInstanceArgs($ruleSpec->arguments);
-
-                return $rule;
-            } catch (ReflectionException) {
-                continue;
-            }
-        }
-
-        throw new ComponentException(sprintf('"%s" is not a valid rule name', $ruleName));
+        return $this->createRuleSpec($this->transformer->transform(new RuleSpec($ruleName, $arguments)));
     }
 
     /**
@@ -165,6 +151,39 @@ final class Factory
         self::$defaultInstance = $defaultInstance;
     }
 
+    private function createRuleSpec(RuleSpec $ruleSpec): Validatable
+    {
+        $rule = $this->createRule($ruleSpec->name, $ruleSpec->arguments);
+        if ($ruleSpec->wrapper !== null) {
+            return $this->createRule($ruleSpec->wrapper->name, array_merge($ruleSpec->wrapper->arguments, [$rule]));
+        }
+
+        return $rule;
+    }
+
+    /**
+     * @param mixed[] $arguments
+     */
+    private function createRule(string $ruleName, array $arguments = []): Validatable
+    {
+        foreach ($this->rulesNamespaces as $namespace) {
+            try {
+                /** @var class-string<Validatable> $name */
+                $name = $namespace . '\\' . ucfirst($ruleName);
+                /** @var Validatable $rule */
+                $rule = $this
+                    ->createReflectionClass($name, Validatable::class)
+                    ->newInstanceArgs($arguments);
+
+                return $rule;
+            } catch (ReflectionException) {
+                continue;
+            }
+        }
+
+        throw new ComponentException(sprintf('"%s" is not a valid rule name', $ruleName));
+    }
+
     /**
      * @param class-string $name
      * @param class-string $parentName
diff --git a/library/Mixins/ChainedKey.php b/library/Mixins/ChainedKey.php
new file mode 100644
index 00000000..c3d66a42
--- /dev/null
+++ b/library/Mixins/ChainedKey.php
@@ -0,0 +1,376 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface ChainedKey
+{
+    public function keyAllOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function keyAlnum(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyAlpha(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyAlwaysInvalid(int|string $key): ChainedValidator;
+
+    public function keyAlwaysValid(int|string $key): ChainedValidator;
+
+    public function keyAnyOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function keyArrayType(int|string $key): ChainedValidator;
+
+    public function keyArrayVal(int|string $key): ChainedValidator;
+
+    public function keyBase(
+        int|string $key,
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public function keyBase64(int|string $key): ChainedValidator;
+
+    public function keyBetween(int|string $key, mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function keyBetweenExclusive(int|string $key, mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function keyBoolType(int|string $key): ChainedValidator;
+
+    public function keyBoolVal(int|string $key): ChainedValidator;
+
+    public function keyBsn(int|string $key): ChainedValidator;
+
+    public function keyCall(int|string $key, callable $callable, Validatable $rule): ChainedValidator;
+
+    public function keyCallableType(int|string $key): ChainedValidator;
+
+    public function keyCallback(int|string $key, callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public function keyCharset(int|string $key, string $charset, string ...$charsets): ChainedValidator;
+
+    public function keyCnh(int|string $key): ChainedValidator;
+
+    public function keyCnpj(int|string $key): ChainedValidator;
+
+    public function keyConsecutive(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function keyConsonant(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyContains(int|string $key, mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function keyContainsAny(int|string $key, array $needles, bool $identical = false): ChainedValidator;
+
+    public function keyControl(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyCountable(int|string $key): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public function keyCountryCode(int|string $key, string $set = 'alpha-2'): ChainedValidator;
+
+    public function keyCpf(int|string $key): ChainedValidator;
+
+    public function keyCreditCard(int|string $key, string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function keyCurrencyCode(int|string $key, string $set = 'alpha-3'): ChainedValidator;
+
+    public function keyDate(int|string $key, string $format = 'Y-m-d'): ChainedValidator;
+
+    public function keyDateTime(int|string $key, ?string $format = null): ChainedValidator;
+
+    public function keyDecimal(int|string $key, int $decimals): ChainedValidator;
+
+    public function keyDigit(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyDirectory(int|string $key): ChainedValidator;
+
+    public function keyDomain(int|string $key, bool $tldCheck = true): ChainedValidator;
+
+    public function keyEach(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyEmail(int|string $key): ChainedValidator;
+
+    public function keyEndsWith(int|string $key, mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public function keyEquals(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyEquivalent(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyEven(int|string $key): ChainedValidator;
+
+    public function keyExecutable(int|string $key): ChainedValidator;
+
+    public function keyExtension(int|string $key, string $extension): ChainedValidator;
+
+    public function keyFactor(int|string $key, int $dividend): ChainedValidator;
+
+    public function keyFalseVal(int|string $key): ChainedValidator;
+
+    public function keyFibonacci(int|string $key): ChainedValidator;
+
+    public function keyFile(int|string $key): ChainedValidator;
+
+    public function keyFilterVar(int|string $key, int $filter, mixed $options = null): ChainedValidator;
+
+    public function keyFinite(int|string $key): ChainedValidator;
+
+    public function keyFloatType(int|string $key): ChainedValidator;
+
+    public function keyFloatVal(int|string $key): ChainedValidator;
+
+    public function keyGraph(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyGreaterThan(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyGreaterThanOrEqual(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyHetu(int|string $key): ChainedValidator;
+
+    public function keyHexRgbColor(int|string $key): ChainedValidator;
+
+    public function keyIban(int|string $key): ChainedValidator;
+
+    public function keyIdentical(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyImage(int|string $key): ChainedValidator;
+
+    public function keyImei(int|string $key): ChainedValidator;
+
+    public function keyIn(int|string $key, mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function keyInfinite(int|string $key): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public function keyInstance(int|string $key, string $class): ChainedValidator;
+
+    public function keyIntType(int|string $key): ChainedValidator;
+
+    public function keyIntVal(int|string $key): ChainedValidator;
+
+    public function keyIp(int|string $key, string $range = '*', ?int $options = null): ChainedValidator;
+
+    public function keyIsbn(int|string $key): ChainedValidator;
+
+    public function keyIterableType(int|string $key): ChainedValidator;
+
+    public function keyIterableVal(int|string $key): ChainedValidator;
+
+    public function keyJson(int|string $key): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public function keyLanguageCode(int|string $key, string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function keyLazy(int|string $key, callable $ruleCreator): ChainedValidator;
+
+    public function keyLeapDate(int|string $key, string $format): ChainedValidator;
+
+    public function keyLeapYear(int|string $key): ChainedValidator;
+
+    public function keyLength(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyLessThan(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyLessThanOrEqual(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public function keyLowercase(int|string $key): ChainedValidator;
+
+    public function keyLuhn(int|string $key): ChainedValidator;
+
+    public function keyMacAddress(int|string $key): ChainedValidator;
+
+    public function keyMax(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyMaxAge(int|string $key, int $age, ?string $format = null): ChainedValidator;
+
+    public function keyMimetype(int|string $key, string $mimetype): ChainedValidator;
+
+    public function keyMin(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyMinAge(int|string $key, int $age, ?string $format = null): ChainedValidator;
+
+    public function keyMultiple(int|string $key, int $multipleOf): ChainedValidator;
+
+    public function keyNegative(int|string $key): ChainedValidator;
+
+    public function keyNfeAccessKey(int|string $key): ChainedValidator;
+
+    public function keyNif(int|string $key): ChainedValidator;
+
+    public function keyNip(int|string $key): ChainedValidator;
+
+    public function keyNo(int|string $key, bool $useLocale = false): ChainedValidator;
+
+    public function keyNoWhitespace(int|string $key): ChainedValidator;
+
+    public function keyNoneOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function keyNot(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyNotBlank(int|string $key): ChainedValidator;
+
+    public function keyNotEmoji(int|string $key): ChainedValidator;
+
+    public function keyNotEmpty(int|string $key): ChainedValidator;
+
+    public function keyNotOptional(int|string $key): ChainedValidator;
+
+    public function keyNullType(int|string $key): ChainedValidator;
+
+    public function keyNullable(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyNumber(int|string $key): ChainedValidator;
+
+    public function keyNumericVal(int|string $key): ChainedValidator;
+
+    public function keyObjectType(int|string $key): ChainedValidator;
+
+    public function keyOdd(int|string $key): ChainedValidator;
+
+    public function keyOneOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function keyOptional(int|string $key, Validatable $rule): ChainedValidator;
+
+    public function keyPerfectSquare(int|string $key): ChainedValidator;
+
+    public function keyPesel(int|string $key): ChainedValidator;
+
+    public function keyPhone(int|string $key, ?string $countryCode = null): ChainedValidator;
+
+    public function keyPhpLabel(int|string $key): ChainedValidator;
+
+    public function keyPis(int|string $key): ChainedValidator;
+
+    public function keyPolishIdCard(int|string $key): ChainedValidator;
+
+    public function keyPortugueseNif(int|string $key): ChainedValidator;
+
+    public function keyPositive(int|string $key): ChainedValidator;
+
+    public function keyPostalCode(int|string $key, string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public function keyPrimeNumber(int|string $key): ChainedValidator;
+
+    public function keyPrintable(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyPublicDomainSuffix(int|string $key): ChainedValidator;
+
+    public function keyPunct(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyReadable(int|string $key): ChainedValidator;
+
+    public function keyRegex(int|string $key, string $regex): ChainedValidator;
+
+    public function keyResourceType(int|string $key): ChainedValidator;
+
+    public function keyRoman(int|string $key): ChainedValidator;
+
+    public function keyScalarVal(int|string $key): ChainedValidator;
+
+    public function keySize(
+        int|string $key,
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public function keySlug(int|string $key): ChainedValidator;
+
+    public function keySorted(int|string $key, string $direction): ChainedValidator;
+
+    public function keySpace(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyStartsWith(int|string $key, mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public function keyStringType(int|string $key): ChainedValidator;
+
+    public function keyStringVal(int|string $key): ChainedValidator;
+
+    public function keySubdivisionCode(int|string $key, string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public function keySubset(int|string $key, array $superset): ChainedValidator;
+
+    public function keySymbolicLink(int|string $key): ChainedValidator;
+
+    public function keyTime(int|string $key, string $format = 'H:i:s'): ChainedValidator;
+
+    public function keyTld(int|string $key): ChainedValidator;
+
+    public function keyTrueVal(int|string $key): ChainedValidator;
+
+    public function keyUnique(int|string $key): ChainedValidator;
+
+    public function keyUploaded(int|string $key): ChainedValidator;
+
+    public function keyUppercase(int|string $key): ChainedValidator;
+
+    public function keyUrl(int|string $key): ChainedValidator;
+
+    public function keyUuid(int|string $key, ?int $version = null): ChainedValidator;
+
+    public function keyVersion(int|string $key): ChainedValidator;
+
+    public function keyVideoUrl(int|string $key, ?string $service = null): ChainedValidator;
+
+    public function keyVowel(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyWhen(
+        int|string $key,
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public function keyWritable(int|string $key): ChainedValidator;
+
+    public function keyXdigit(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public function keyYes(int|string $key, bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedLength.php b/library/Mixins/ChainedLength.php
new file mode 100644
index 00000000..2565ce48
--- /dev/null
+++ b/library/Mixins/ChainedLength.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface ChainedLength
+{
+    public function lengthBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function lengthBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function lengthEquals(mixed $compareTo): ChainedValidator;
+
+    public function lengthEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function lengthEven(): ChainedValidator;
+
+    public function lengthFactor(int $dividend): ChainedValidator;
+
+    public function lengthFibonacci(): ChainedValidator;
+
+    public function lengthFinite(): ChainedValidator;
+
+    public function lengthGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function lengthGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function lengthIdentical(mixed $compareTo): ChainedValidator;
+
+    public function lengthIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function lengthInfinite(): ChainedValidator;
+
+    public function lengthLessThan(mixed $compareTo): ChainedValidator;
+
+    public function lengthLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function lengthMultiple(int $multipleOf): ChainedValidator;
+
+    public function lengthOdd(): ChainedValidator;
+
+    public function lengthPerfectSquare(): ChainedValidator;
+
+    public function lengthPositive(): ChainedValidator;
+
+    public function lengthPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedMax.php b/library/Mixins/ChainedMax.php
new file mode 100644
index 00000000..ba6cc9ca
--- /dev/null
+++ b/library/Mixins/ChainedMax.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface ChainedMax
+{
+    public function maxBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function maxBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function maxEquals(mixed $compareTo): ChainedValidator;
+
+    public function maxEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function maxEven(): ChainedValidator;
+
+    public function maxFactor(int $dividend): ChainedValidator;
+
+    public function maxFibonacci(): ChainedValidator;
+
+    public function maxFinite(): ChainedValidator;
+
+    public function maxGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function maxGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function maxIdentical(mixed $compareTo): ChainedValidator;
+
+    public function maxIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function maxInfinite(): ChainedValidator;
+
+    public function maxLessThan(mixed $compareTo): ChainedValidator;
+
+    public function maxLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function maxMultiple(int $multipleOf): ChainedValidator;
+
+    public function maxOdd(): ChainedValidator;
+
+    public function maxPerfectSquare(): ChainedValidator;
+
+    public function maxPositive(): ChainedValidator;
+
+    public function maxPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedMin.php b/library/Mixins/ChainedMin.php
new file mode 100644
index 00000000..a072e39b
--- /dev/null
+++ b/library/Mixins/ChainedMin.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface ChainedMin
+{
+    public function minBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function minBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function minEquals(mixed $compareTo): ChainedValidator;
+
+    public function minEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function minEven(): ChainedValidator;
+
+    public function minFactor(int $dividend): ChainedValidator;
+
+    public function minFibonacci(): ChainedValidator;
+
+    public function minFinite(): ChainedValidator;
+
+    public function minGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function minGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function minIdentical(mixed $compareTo): ChainedValidator;
+
+    public function minIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function minInfinite(): ChainedValidator;
+
+    public function minLessThan(mixed $compareTo): ChainedValidator;
+
+    public function minLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function minMultiple(int $multipleOf): ChainedValidator;
+
+    public function minOdd(): ChainedValidator;
+
+    public function minPerfectSquare(): ChainedValidator;
+
+    public function minPositive(): ChainedValidator;
+
+    public function minPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedNot.php b/library/Mixins/ChainedNot.php
new file mode 100644
index 00000000..9c75023c
--- /dev/null
+++ b/library/Mixins/ChainedNot.php
@@ -0,0 +1,345 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface ChainedNot
+{
+    public function notAllOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function notAlnum(string ...$additionalChars): ChainedValidator;
+
+    public function notAlpha(string ...$additionalChars): ChainedValidator;
+
+    public function notAlwaysInvalid(): ChainedValidator;
+
+    public function notAlwaysValid(): ChainedValidator;
+
+    public function notAnyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function notArrayType(): ChainedValidator;
+
+    public function notArrayVal(): ChainedValidator;
+
+    public function notBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public function notBase64(): ChainedValidator;
+
+    public function notBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function notBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function notBoolType(): ChainedValidator;
+
+    public function notBoolVal(): ChainedValidator;
+
+    public function notBsn(): ChainedValidator;
+
+    public function notCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public function notCallableType(): ChainedValidator;
+
+    public function notCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public function notCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public function notCnh(): ChainedValidator;
+
+    public function notCnpj(): ChainedValidator;
+
+    public function notConsecutive(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function notConsonant(string ...$additionalChars): ChainedValidator;
+
+    public function notContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function notContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public function notControl(string ...$additionalChars): ChainedValidator;
+
+    public function notCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public function notCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public function notCpf(): ChainedValidator;
+
+    public function notCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function notCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public function notDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public function notDateTime(?string $format = null): ChainedValidator;
+
+    public function notDecimal(int $decimals): ChainedValidator;
+
+    public function notDigit(string ...$additionalChars): ChainedValidator;
+
+    public function notDirectory(): ChainedValidator;
+
+    public function notDomain(bool $tldCheck = true): ChainedValidator;
+
+    public function notEach(Validatable $rule): ChainedValidator;
+
+    public function notEmail(): ChainedValidator;
+
+    public function notEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public function notEquals(mixed $compareTo): ChainedValidator;
+
+    public function notEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function notEven(): ChainedValidator;
+
+    public function notExecutable(): ChainedValidator;
+
+    public function notExists(): ChainedValidator;
+
+    public function notExtension(string $extension): ChainedValidator;
+
+    public function notFactor(int $dividend): ChainedValidator;
+
+    public function notFalseVal(): ChainedValidator;
+
+    public function notFibonacci(): ChainedValidator;
+
+    public function notFile(): ChainedValidator;
+
+    public function notFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public function notFinite(): ChainedValidator;
+
+    public function notFloatType(): ChainedValidator;
+
+    public function notFloatVal(): ChainedValidator;
+
+    public function notGraph(string ...$additionalChars): ChainedValidator;
+
+    public function notGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function notGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function notHetu(): ChainedValidator;
+
+    public function notHexRgbColor(): ChainedValidator;
+
+    public function notIban(): ChainedValidator;
+
+    public function notIdentical(mixed $compareTo): ChainedValidator;
+
+    public function notImage(): ChainedValidator;
+
+    public function notImei(): ChainedValidator;
+
+    public function notIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function notInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public function notInstance(string $class): ChainedValidator;
+
+    public function notIntType(): ChainedValidator;
+
+    public function notIntVal(): ChainedValidator;
+
+    public function notIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public function notIsbn(): ChainedValidator;
+
+    public function notIterableType(): ChainedValidator;
+
+    public function notIterableVal(): ChainedValidator;
+
+    public function notJson(): ChainedValidator;
+
+    public function notKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function notKeyExists(string|int $key): ChainedValidator;
+
+    public function notKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function notKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public function notLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function notLazy(callable $ruleCreator): ChainedValidator;
+
+    public function notLeapDate(string $format): ChainedValidator;
+
+    public function notLeapYear(): ChainedValidator;
+
+    public function notLength(Validatable $rule): ChainedValidator;
+
+    public function notLessThan(mixed $compareTo): ChainedValidator;
+
+    public function notLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function notLowercase(): ChainedValidator;
+
+    public function notLuhn(): ChainedValidator;
+
+    public function notMacAddress(): ChainedValidator;
+
+    public function notMax(Validatable $rule): ChainedValidator;
+
+    public function notMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function notMimetype(string $mimetype): ChainedValidator;
+
+    public function notMin(Validatable $rule): ChainedValidator;
+
+    public function notMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function notMultiple(int $multipleOf): ChainedValidator;
+
+    public function notNegative(): ChainedValidator;
+
+    public function notNfeAccessKey(): ChainedValidator;
+
+    public function notNif(): ChainedValidator;
+
+    public function notNip(): ChainedValidator;
+
+    public function notNo(bool $useLocale = false): ChainedValidator;
+
+    public function notNoWhitespace(): ChainedValidator;
+
+    public function notNoneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function notNullType(): ChainedValidator;
+
+    public function notNullable(Validatable $rule): ChainedValidator;
+
+    public function notNumber(): ChainedValidator;
+
+    public function notNumericVal(): ChainedValidator;
+
+    public function notObjectType(): ChainedValidator;
+
+    public function notOdd(): ChainedValidator;
+
+    public function notOneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function notPerfectSquare(): ChainedValidator;
+
+    public function notPesel(): ChainedValidator;
+
+    public function notPhone(?string $countryCode = null): ChainedValidator;
+
+    public function notPhpLabel(): ChainedValidator;
+
+    public function notPis(): ChainedValidator;
+
+    public function notPolishIdCard(): ChainedValidator;
+
+    public function notPortugueseNif(): ChainedValidator;
+
+    public function notPositive(): ChainedValidator;
+
+    public function notPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public function notPrimeNumber(): ChainedValidator;
+
+    public function notPrintable(string ...$additionalChars): ChainedValidator;
+
+    public function notProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function notPropertyExists(string $propertyName): ChainedValidator;
+
+    public function notPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function notPublicDomainSuffix(): ChainedValidator;
+
+    public function notPunct(string ...$additionalChars): ChainedValidator;
+
+    public function notReadable(): ChainedValidator;
+
+    public function notRegex(string $regex): ChainedValidator;
+
+    public function notResourceType(): ChainedValidator;
+
+    public function notRoman(): ChainedValidator;
+
+    public function notScalarVal(): ChainedValidator;
+
+    public function notSize(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
+
+    public function notSlug(): ChainedValidator;
+
+    public function notSorted(string $direction): ChainedValidator;
+
+    public function notSpace(string ...$additionalChars): ChainedValidator;
+
+    public function notStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public function notStringType(): ChainedValidator;
+
+    public function notStringVal(): ChainedValidator;
+
+    public function notSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public function notSubset(array $superset): ChainedValidator;
+
+    public function notSymbolicLink(): ChainedValidator;
+
+    public function notTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public function notTld(): ChainedValidator;
+
+    public function notTrueVal(): ChainedValidator;
+
+    public function notUnique(): ChainedValidator;
+
+    public function notUploaded(): ChainedValidator;
+
+    public function notUppercase(): ChainedValidator;
+
+    public function notUrl(): ChainedValidator;
+
+    public function notUuid(?int $version = null): ChainedValidator;
+
+    public function notVersion(): ChainedValidator;
+
+    public function notVideoUrl(?string $service = null): ChainedValidator;
+
+    public function notVowel(string ...$additionalChars): ChainedValidator;
+
+    public function notWhen(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
+
+    public function notWritable(): ChainedValidator;
+
+    public function notXdigit(string ...$additionalChars): ChainedValidator;
+
+    public function notYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedNullOr.php b/library/Mixins/ChainedNullOr.php
new file mode 100644
index 00000000..72ba2140
--- /dev/null
+++ b/library/Mixins/ChainedNullOr.php
@@ -0,0 +1,353 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface ChainedNullOr
+{
+    public function nullOfAllOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function nullOfAlnum(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfAlpha(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfAlwaysInvalid(): ChainedValidator;
+
+    public function nullOfAlwaysValid(): ChainedValidator;
+
+    public function nullOfAnyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function nullOfArrayType(): ChainedValidator;
+
+    public function nullOfArrayVal(): ChainedValidator;
+
+    public function nullOfBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public function nullOfBase64(): ChainedValidator;
+
+    public function nullOfBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function nullOfBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function nullOfBoolType(): ChainedValidator;
+
+    public function nullOfBoolVal(): ChainedValidator;
+
+    public function nullOfBsn(): ChainedValidator;
+
+    public function nullOfCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public function nullOfCallableType(): ChainedValidator;
+
+    public function nullOfCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public function nullOfCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public function nullOfCnh(): ChainedValidator;
+
+    public function nullOfCnpj(): ChainedValidator;
+
+    public function nullOfConsecutive(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function nullOfConsonant(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function nullOfContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public function nullOfControl(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public function nullOfCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public function nullOfCpf(): ChainedValidator;
+
+    public function nullOfCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function nullOfCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public function nullOfDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public function nullOfDateTime(?string $format = null): ChainedValidator;
+
+    public function nullOfDecimal(int $decimals): ChainedValidator;
+
+    public function nullOfDigit(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfDirectory(): ChainedValidator;
+
+    public function nullOfDomain(bool $tldCheck = true): ChainedValidator;
+
+    public function nullOfEach(Validatable $rule): ChainedValidator;
+
+    public function nullOfEmail(): ChainedValidator;
+
+    public function nullOfEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public function nullOfEquals(mixed $compareTo): ChainedValidator;
+
+    public function nullOfEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function nullOfEven(): ChainedValidator;
+
+    public function nullOfExecutable(): ChainedValidator;
+
+    public function nullOfExists(): ChainedValidator;
+
+    public function nullOfExtension(string $extension): ChainedValidator;
+
+    public function nullOfFactor(int $dividend): ChainedValidator;
+
+    public function nullOfFalseVal(): ChainedValidator;
+
+    public function nullOfFibonacci(): ChainedValidator;
+
+    public function nullOfFile(): ChainedValidator;
+
+    public function nullOfFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public function nullOfFinite(): ChainedValidator;
+
+    public function nullOfFloatType(): ChainedValidator;
+
+    public function nullOfFloatVal(): ChainedValidator;
+
+    public function nullOfGraph(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function nullOfGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function nullOfHetu(): ChainedValidator;
+
+    public function nullOfHexRgbColor(): ChainedValidator;
+
+    public function nullOfIban(): ChainedValidator;
+
+    public function nullOfIdentical(mixed $compareTo): ChainedValidator;
+
+    public function nullOfImage(): ChainedValidator;
+
+    public function nullOfImei(): ChainedValidator;
+
+    public function nullOfIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function nullOfInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public function nullOfInstance(string $class): ChainedValidator;
+
+    public function nullOfIntType(): ChainedValidator;
+
+    public function nullOfIntVal(): ChainedValidator;
+
+    public function nullOfIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public function nullOfIsbn(): ChainedValidator;
+
+    public function nullOfIterableType(): ChainedValidator;
+
+    public function nullOfIterableVal(): ChainedValidator;
+
+    public function nullOfJson(): ChainedValidator;
+
+    public function nullOfKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function nullOfKeyExists(string|int $key): ChainedValidator;
+
+    public function nullOfKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function nullOfKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public function nullOfLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function nullOfLazy(callable $ruleCreator): ChainedValidator;
+
+    public function nullOfLeapDate(string $format): ChainedValidator;
+
+    public function nullOfLeapYear(): ChainedValidator;
+
+    public function nullOfLength(Validatable $rule): ChainedValidator;
+
+    public function nullOfLessThan(mixed $compareTo): ChainedValidator;
+
+    public function nullOfLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function nullOfLowercase(): ChainedValidator;
+
+    public function nullOfLuhn(): ChainedValidator;
+
+    public function nullOfMacAddress(): ChainedValidator;
+
+    public function nullOfMax(Validatable $rule): ChainedValidator;
+
+    public function nullOfMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function nullOfMimetype(string $mimetype): ChainedValidator;
+
+    public function nullOfMin(Validatable $rule): ChainedValidator;
+
+    public function nullOfMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function nullOfMultiple(int $multipleOf): ChainedValidator;
+
+    public function nullOfNegative(): ChainedValidator;
+
+    public function nullOfNfeAccessKey(): ChainedValidator;
+
+    public function nullOfNif(): ChainedValidator;
+
+    public function nullOfNip(): ChainedValidator;
+
+    public function nullOfNo(bool $useLocale = false): ChainedValidator;
+
+    public function nullOfNoWhitespace(): ChainedValidator;
+
+    public function nullOfNoneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function nullOfNot(Validatable $rule): ChainedValidator;
+
+    public function nullOfNotBlank(): ChainedValidator;
+
+    public function nullOfNotEmoji(): ChainedValidator;
+
+    public function nullOfNotEmpty(): ChainedValidator;
+
+    public function nullOfNotOptional(): ChainedValidator;
+
+    public function nullOfNullType(): ChainedValidator;
+
+    public function nullOfNumber(): ChainedValidator;
+
+    public function nullOfNumericVal(): ChainedValidator;
+
+    public function nullOfObjectType(): ChainedValidator;
+
+    public function nullOfOdd(): ChainedValidator;
+
+    public function nullOfOneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function nullOfPerfectSquare(): ChainedValidator;
+
+    public function nullOfPesel(): ChainedValidator;
+
+    public function nullOfPhone(?string $countryCode = null): ChainedValidator;
+
+    public function nullOfPhpLabel(): ChainedValidator;
+
+    public function nullOfPis(): ChainedValidator;
+
+    public function nullOfPolishIdCard(): ChainedValidator;
+
+    public function nullOfPortugueseNif(): ChainedValidator;
+
+    public function nullOfPositive(): ChainedValidator;
+
+    public function nullOfPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public function nullOfPrimeNumber(): ChainedValidator;
+
+    public function nullOfPrintable(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function nullOfPropertyExists(string $propertyName): ChainedValidator;
+
+    public function nullOfPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function nullOfPublicDomainSuffix(): ChainedValidator;
+
+    public function nullOfPunct(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfReadable(): ChainedValidator;
+
+    public function nullOfRegex(string $regex): ChainedValidator;
+
+    public function nullOfResourceType(): ChainedValidator;
+
+    public function nullOfRoman(): ChainedValidator;
+
+    public function nullOfScalarVal(): ChainedValidator;
+
+    public function nullOfSize(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
+
+    public function nullOfSlug(): ChainedValidator;
+
+    public function nullOfSorted(string $direction): ChainedValidator;
+
+    public function nullOfSpace(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public function nullOfStringType(): ChainedValidator;
+
+    public function nullOfStringVal(): ChainedValidator;
+
+    public function nullOfSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public function nullOfSubset(array $superset): ChainedValidator;
+
+    public function nullOfSymbolicLink(): ChainedValidator;
+
+    public function nullOfTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public function nullOfTld(): ChainedValidator;
+
+    public function nullOfTrueVal(): ChainedValidator;
+
+    public function nullOfUnique(): ChainedValidator;
+
+    public function nullOfUploaded(): ChainedValidator;
+
+    public function nullOfUppercase(): ChainedValidator;
+
+    public function nullOfUrl(): ChainedValidator;
+
+    public function nullOfUuid(?int $version = null): ChainedValidator;
+
+    public function nullOfVersion(): ChainedValidator;
+
+    public function nullOfVideoUrl(?string $service = null): ChainedValidator;
+
+    public function nullOfVowel(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfWhen(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
+
+    public function nullOfWritable(): ChainedValidator;
+
+    public function nullOfXdigit(string ...$additionalChars): ChainedValidator;
+
+    public function nullOfYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedProperty.php b/library/Mixins/ChainedProperty.php
new file mode 100644
index 00000000..b2715639
--- /dev/null
+++ b/library/Mixins/ChainedProperty.php
@@ -0,0 +1,396 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface ChainedProperty
+{
+    public function propertyAllOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function propertyAlnum(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyAlpha(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyAlwaysInvalid(string $propertyName): ChainedValidator;
+
+    public function propertyAlwaysValid(string $propertyName): ChainedValidator;
+
+    public function propertyAnyOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function propertyArrayType(string $propertyName): ChainedValidator;
+
+    public function propertyArrayVal(string $propertyName): ChainedValidator;
+
+    public function propertyBase(
+        string $propertyName,
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public function propertyBase64(string $propertyName): ChainedValidator;
+
+    public function propertyBetween(string $propertyName, mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function propertyBetweenExclusive(string $propertyName, mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function propertyBoolType(string $propertyName): ChainedValidator;
+
+    public function propertyBoolVal(string $propertyName): ChainedValidator;
+
+    public function propertyBsn(string $propertyName): ChainedValidator;
+
+    public function propertyCall(string $propertyName, callable $callable, Validatable $rule): ChainedValidator;
+
+    public function propertyCallableType(string $propertyName): ChainedValidator;
+
+    public function propertyCallback(string $propertyName, callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public function propertyCharset(string $propertyName, string $charset, string ...$charsets): ChainedValidator;
+
+    public function propertyCnh(string $propertyName): ChainedValidator;
+
+    public function propertyCnpj(string $propertyName): ChainedValidator;
+
+    public function propertyConsecutive(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function propertyConsonant(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyContains(
+        string $propertyName,
+        mixed $containsValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function propertyContainsAny(
+        string $propertyName,
+        array $needles,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public function propertyControl(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyCountable(string $propertyName): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public function propertyCountryCode(string $propertyName, string $set = 'alpha-2'): ChainedValidator;
+
+    public function propertyCpf(string $propertyName): ChainedValidator;
+
+    public function propertyCreditCard(string $propertyName, string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function propertyCurrencyCode(string $propertyName, string $set = 'alpha-3'): ChainedValidator;
+
+    public function propertyDate(string $propertyName, string $format = 'Y-m-d'): ChainedValidator;
+
+    public function propertyDateTime(string $propertyName, ?string $format = null): ChainedValidator;
+
+    public function propertyDecimal(string $propertyName, int $decimals): ChainedValidator;
+
+    public function propertyDigit(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyDirectory(string $propertyName): ChainedValidator;
+
+    public function propertyDomain(string $propertyName, bool $tldCheck = true): ChainedValidator;
+
+    public function propertyEach(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyEmail(string $propertyName): ChainedValidator;
+
+    public function propertyEndsWith(string $propertyName, mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public function propertyEquals(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyEquivalent(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyEven(string $propertyName): ChainedValidator;
+
+    public function propertyExecutable(string $propertyName): ChainedValidator;
+
+    public function propertyExtension(string $propertyName, string $extension): ChainedValidator;
+
+    public function propertyFactor(string $propertyName, int $dividend): ChainedValidator;
+
+    public function propertyFalseVal(string $propertyName): ChainedValidator;
+
+    public function propertyFibonacci(string $propertyName): ChainedValidator;
+
+    public function propertyFile(string $propertyName): ChainedValidator;
+
+    public function propertyFilterVar(string $propertyName, int $filter, mixed $options = null): ChainedValidator;
+
+    public function propertyFinite(string $propertyName): ChainedValidator;
+
+    public function propertyFloatType(string $propertyName): ChainedValidator;
+
+    public function propertyFloatVal(string $propertyName): ChainedValidator;
+
+    public function propertyGraph(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyGreaterThan(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyGreaterThanOrEqual(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyHetu(string $propertyName): ChainedValidator;
+
+    public function propertyHexRgbColor(string $propertyName): ChainedValidator;
+
+    public function propertyIban(string $propertyName): ChainedValidator;
+
+    public function propertyIdentical(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyImage(string $propertyName): ChainedValidator;
+
+    public function propertyImei(string $propertyName): ChainedValidator;
+
+    public function propertyIn(
+        string $propertyName,
+        mixed $haystack,
+        bool $compareIdentical = false,
+    ): ChainedValidator;
+
+    public function propertyInfinite(string $propertyName): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public function propertyInstance(string $propertyName, string $class): ChainedValidator;
+
+    public function propertyIntType(string $propertyName): ChainedValidator;
+
+    public function propertyIntVal(string $propertyName): ChainedValidator;
+
+    public function propertyIp(string $propertyName, string $range = '*', ?int $options = null): ChainedValidator;
+
+    public function propertyIsbn(string $propertyName): ChainedValidator;
+
+    public function propertyIterableType(string $propertyName): ChainedValidator;
+
+    public function propertyIterableVal(string $propertyName): ChainedValidator;
+
+    public function propertyJson(string $propertyName): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public function propertyLanguageCode(string $propertyName, string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function propertyLazy(string $propertyName, callable $ruleCreator): ChainedValidator;
+
+    public function propertyLeapDate(string $propertyName, string $format): ChainedValidator;
+
+    public function propertyLeapYear(string $propertyName): ChainedValidator;
+
+    public function propertyLength(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyLessThan(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyLessThanOrEqual(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public function propertyLowercase(string $propertyName): ChainedValidator;
+
+    public function propertyLuhn(string $propertyName): ChainedValidator;
+
+    public function propertyMacAddress(string $propertyName): ChainedValidator;
+
+    public function propertyMax(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyMaxAge(string $propertyName, int $age, ?string $format = null): ChainedValidator;
+
+    public function propertyMimetype(string $propertyName, string $mimetype): ChainedValidator;
+
+    public function propertyMin(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyMinAge(string $propertyName, int $age, ?string $format = null): ChainedValidator;
+
+    public function propertyMultiple(string $propertyName, int $multipleOf): ChainedValidator;
+
+    public function propertyNegative(string $propertyName): ChainedValidator;
+
+    public function propertyNfeAccessKey(string $propertyName): ChainedValidator;
+
+    public function propertyNif(string $propertyName): ChainedValidator;
+
+    public function propertyNip(string $propertyName): ChainedValidator;
+
+    public function propertyNo(string $propertyName, bool $useLocale = false): ChainedValidator;
+
+    public function propertyNoWhitespace(string $propertyName): ChainedValidator;
+
+    public function propertyNoneOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function propertyNot(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyNotBlank(string $propertyName): ChainedValidator;
+
+    public function propertyNotEmoji(string $propertyName): ChainedValidator;
+
+    public function propertyNotEmpty(string $propertyName): ChainedValidator;
+
+    public function propertyNotOptional(string $propertyName): ChainedValidator;
+
+    public function propertyNullType(string $propertyName): ChainedValidator;
+
+    public function propertyNullable(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyNumber(string $propertyName): ChainedValidator;
+
+    public function propertyNumericVal(string $propertyName): ChainedValidator;
+
+    public function propertyObjectType(string $propertyName): ChainedValidator;
+
+    public function propertyOdd(string $propertyName): ChainedValidator;
+
+    public function propertyOneOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function propertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyPerfectSquare(string $propertyName): ChainedValidator;
+
+    public function propertyPesel(string $propertyName): ChainedValidator;
+
+    public function propertyPhone(string $propertyName, ?string $countryCode = null): ChainedValidator;
+
+    public function propertyPhpLabel(string $propertyName): ChainedValidator;
+
+    public function propertyPis(string $propertyName): ChainedValidator;
+
+    public function propertyPolishIdCard(string $propertyName): ChainedValidator;
+
+    public function propertyPortugueseNif(string $propertyName): ChainedValidator;
+
+    public function propertyPositive(string $propertyName): ChainedValidator;
+
+    public function propertyPostalCode(
+        string $propertyName,
+        string $countryCode,
+        bool $formatted = false,
+    ): ChainedValidator;
+
+    public function propertyPrimeNumber(string $propertyName): ChainedValidator;
+
+    public function propertyPrintable(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyPublicDomainSuffix(string $propertyName): ChainedValidator;
+
+    public function propertyPunct(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyReadable(string $propertyName): ChainedValidator;
+
+    public function propertyRegex(string $propertyName, string $regex): ChainedValidator;
+
+    public function propertyResourceType(string $propertyName): ChainedValidator;
+
+    public function propertyRoman(string $propertyName): ChainedValidator;
+
+    public function propertyScalarVal(string $propertyName): ChainedValidator;
+
+    public function propertySize(
+        string $propertyName,
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public function propertySlug(string $propertyName): ChainedValidator;
+
+    public function propertySorted(string $propertyName, string $direction): ChainedValidator;
+
+    public function propertySpace(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyStartsWith(
+        string $propertyName,
+        mixed $startValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public function propertyStringType(string $propertyName): ChainedValidator;
+
+    public function propertyStringVal(string $propertyName): ChainedValidator;
+
+    public function propertySubdivisionCode(string $propertyName, string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public function propertySubset(string $propertyName, array $superset): ChainedValidator;
+
+    public function propertySymbolicLink(string $propertyName): ChainedValidator;
+
+    public function propertyTime(string $propertyName, string $format = 'H:i:s'): ChainedValidator;
+
+    public function propertyTld(string $propertyName): ChainedValidator;
+
+    public function propertyTrueVal(string $propertyName): ChainedValidator;
+
+    public function propertyUnique(string $propertyName): ChainedValidator;
+
+    public function propertyUploaded(string $propertyName): ChainedValidator;
+
+    public function propertyUppercase(string $propertyName): ChainedValidator;
+
+    public function propertyUrl(string $propertyName): ChainedValidator;
+
+    public function propertyUuid(string $propertyName, ?int $version = null): ChainedValidator;
+
+    public function propertyVersion(string $propertyName): ChainedValidator;
+
+    public function propertyVideoUrl(string $propertyName, ?string $service = null): ChainedValidator;
+
+    public function propertyVowel(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyWhen(
+        string $propertyName,
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public function propertyWritable(string $propertyName): ChainedValidator;
+
+    public function propertyXdigit(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public function propertyYes(string $propertyName, bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedUndefOr.php b/library/Mixins/ChainedUndefOr.php
new file mode 100644
index 00000000..09b51e08
--- /dev/null
+++ b/library/Mixins/ChainedUndefOr.php
@@ -0,0 +1,357 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface ChainedUndefOr
+{
+    public function undefOfAllOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function undefOfAlnum(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfAlpha(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfAlwaysInvalid(): ChainedValidator;
+
+    public function undefOfAlwaysValid(): ChainedValidator;
+
+    public function undefOfAnyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function undefOfArrayType(): ChainedValidator;
+
+    public function undefOfArrayVal(): ChainedValidator;
+
+    public function undefOfBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public function undefOfBase64(): ChainedValidator;
+
+    public function undefOfBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public function undefOfBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public function undefOfBoolType(): ChainedValidator;
+
+    public function undefOfBoolVal(): ChainedValidator;
+
+    public function undefOfBsn(): ChainedValidator;
+
+    public function undefOfCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public function undefOfCallableType(): ChainedValidator;
+
+    public function undefOfCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public function undefOfCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public function undefOfCnh(): ChainedValidator;
+
+    public function undefOfCnpj(): ChainedValidator;
+
+    public function undefOfConsecutive(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public function undefOfConsonant(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function undefOfContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public function undefOfControl(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public function undefOfCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public function undefOfCpf(): ChainedValidator;
+
+    public function undefOfCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function undefOfCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public function undefOfDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public function undefOfDateTime(?string $format = null): ChainedValidator;
+
+    public function undefOfDecimal(int $decimals): ChainedValidator;
+
+    public function undefOfDigit(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfDirectory(): ChainedValidator;
+
+    public function undefOfDomain(bool $tldCheck = true): ChainedValidator;
+
+    public function undefOfEach(Validatable $rule): ChainedValidator;
+
+    public function undefOfEmail(): ChainedValidator;
+
+    public function undefOfEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public function undefOfEquals(mixed $compareTo): ChainedValidator;
+
+    public function undefOfEquivalent(mixed $compareTo): ChainedValidator;
+
+    public function undefOfEven(): ChainedValidator;
+
+    public function undefOfExecutable(): ChainedValidator;
+
+    public function undefOfExists(): ChainedValidator;
+
+    public function undefOfExtension(string $extension): ChainedValidator;
+
+    public function undefOfFactor(int $dividend): ChainedValidator;
+
+    public function undefOfFalseVal(): ChainedValidator;
+
+    public function undefOfFibonacci(): ChainedValidator;
+
+    public function undefOfFile(): ChainedValidator;
+
+    public function undefOfFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public function undefOfFinite(): ChainedValidator;
+
+    public function undefOfFloatType(): ChainedValidator;
+
+    public function undefOfFloatVal(): ChainedValidator;
+
+    public function undefOfGraph(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public function undefOfGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function undefOfHetu(): ChainedValidator;
+
+    public function undefOfHexRgbColor(): ChainedValidator;
+
+    public function undefOfIban(): ChainedValidator;
+
+    public function undefOfIdentical(mixed $compareTo): ChainedValidator;
+
+    public function undefOfImage(): ChainedValidator;
+
+    public function undefOfImei(): ChainedValidator;
+
+    public function undefOfIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public function undefOfInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public function undefOfInstance(string $class): ChainedValidator;
+
+    public function undefOfIntType(): ChainedValidator;
+
+    public function undefOfIntVal(): ChainedValidator;
+
+    public function undefOfIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public function undefOfIsbn(): ChainedValidator;
+
+    public function undefOfIterableType(): ChainedValidator;
+
+    public function undefOfIterableVal(): ChainedValidator;
+
+    public function undefOfJson(): ChainedValidator;
+
+    public function undefOfKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function undefOfKeyExists(string|int $key): ChainedValidator;
+
+    public function undefOfKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public function undefOfKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public function undefOfLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function undefOfLazy(callable $ruleCreator): ChainedValidator;
+
+    public function undefOfLeapDate(string $format): ChainedValidator;
+
+    public function undefOfLeapYear(): ChainedValidator;
+
+    public function undefOfLength(Validatable $rule): ChainedValidator;
+
+    public function undefOfLessThan(mixed $compareTo): ChainedValidator;
+
+    public function undefOfLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function undefOfLowercase(): ChainedValidator;
+
+    public function undefOfLuhn(): ChainedValidator;
+
+    public function undefOfMacAddress(): ChainedValidator;
+
+    public function undefOfMax(Validatable $rule): ChainedValidator;
+
+    public function undefOfMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function undefOfMimetype(string $mimetype): ChainedValidator;
+
+    public function undefOfMin(Validatable $rule): ChainedValidator;
+
+    public function undefOfMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public function undefOfMultiple(int $multipleOf): ChainedValidator;
+
+    public function undefOfNegative(): ChainedValidator;
+
+    public function undefOfNfeAccessKey(): ChainedValidator;
+
+    public function undefOfNif(): ChainedValidator;
+
+    public function undefOfNip(): ChainedValidator;
+
+    public function undefOfNo(bool $useLocale = false): ChainedValidator;
+
+    public function undefOfNoWhitespace(): ChainedValidator;
+
+    public function undefOfNoneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function undefOfNot(Validatable $rule): ChainedValidator;
+
+    public function undefOfNotBlank(): ChainedValidator;
+
+    public function undefOfNotEmoji(): ChainedValidator;
+
+    public function undefOfNotEmpty(): ChainedValidator;
+
+    public function undefOfNotOptional(): ChainedValidator;
+
+    public function undefOfNullType(): ChainedValidator;
+
+    public function undefOfNumber(): ChainedValidator;
+
+    public function undefOfNumericVal(): ChainedValidator;
+
+    public function undefOfObjectType(): ChainedValidator;
+
+    public function undefOfOdd(): ChainedValidator;
+
+    public function undefOfOneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public function undefOfPerfectSquare(): ChainedValidator;
+
+    public function undefOfPesel(): ChainedValidator;
+
+    public function undefOfPhone(?string $countryCode = null): ChainedValidator;
+
+    public function undefOfPhpLabel(): ChainedValidator;
+
+    public function undefOfPis(): ChainedValidator;
+
+    public function undefOfPolishIdCard(): ChainedValidator;
+
+    public function undefOfPortugueseNif(): ChainedValidator;
+
+    public function undefOfPositive(): ChainedValidator;
+
+    public function undefOfPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public function undefOfPrimeNumber(): ChainedValidator;
+
+    public function undefOfPrintable(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function undefOfPropertyExists(string $propertyName): ChainedValidator;
+
+    public function undefOfPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function undefOfPublicDomainSuffix(): ChainedValidator;
+
+    public function undefOfPunct(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfReadable(): ChainedValidator;
+
+    public function undefOfRegex(string $regex): ChainedValidator;
+
+    public function undefOfResourceType(): ChainedValidator;
+
+    public function undefOfRoman(): ChainedValidator;
+
+    public function undefOfScalarVal(): ChainedValidator;
+
+    public function undefOfSize(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
+
+    public function undefOfSlug(): ChainedValidator;
+
+    public function undefOfSorted(string $direction): ChainedValidator;
+
+    public function undefOfSpace(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public function undefOfStringType(): ChainedValidator;
+
+    public function undefOfStringVal(): ChainedValidator;
+
+    public function undefOfSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public function undefOfSubset(array $superset): ChainedValidator;
+
+    public function undefOfSymbolicLink(): ChainedValidator;
+
+    public function undefOfTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public function undefOfTld(): ChainedValidator;
+
+    public function undefOfTrueVal(): ChainedValidator;
+
+    public function undefOfUnique(): ChainedValidator;
+
+    public function undefOfUploaded(): ChainedValidator;
+
+    public function undefOfUppercase(): ChainedValidator;
+
+    public function undefOfUrl(): ChainedValidator;
+
+    public function undefOfUuid(?int $version = null): ChainedValidator;
+
+    public function undefOfVersion(): ChainedValidator;
+
+    public function undefOfVideoUrl(?string $service = null): ChainedValidator;
+
+    public function undefOfVowel(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfWhen(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
+
+    public function undefOfWritable(): ChainedValidator;
+
+    public function undefOfXdigit(string ...$additionalChars): ChainedValidator;
+
+    public function undefOfYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/ChainedValidator.php b/library/Mixins/ChainedValidator.php
index ef8ac36e..1c3b818c 100644
--- a/library/Mixins/ChainedValidator.php
+++ b/library/Mixins/ChainedValidator.php
@@ -9,12 +9,20 @@ declare(strict_types=1);
 
 namespace Respect\Validation\Mixins;
 
-use finfo;
 use Respect\Validation\Validatable;
 
-interface ChainedValidator extends Validatable
+interface ChainedValidator extends
+    Validatable,
+    ChainedKey,
+    ChainedLength,
+    ChainedMax,
+    ChainedMin,
+    ChainedNot,
+    ChainedNullOr,
+    ChainedProperty,
+    ChainedUndefOr
 {
-    public function allOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public function allOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public function alnum(string ...$additionalChars): ChainedValidator;
 
@@ -24,23 +32,20 @@ interface ChainedValidator extends Validatable
 
     public function alwaysValid(): ChainedValidator;
 
-    public function anyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public function anyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public function arrayType(): ChainedValidator;
 
     public function arrayVal(): ChainedValidator;
 
-    public function property(string $propertyName, Validatable $validator): ChainedValidator;
-
-    public function propertyExists(string $propertyName): ChainedValidator;
-
-    public function propertyOptional(string $propertyName, Validatable $validator): ChainedValidator;
-
-    public function base(int $base, ?string $chars = null): ChainedValidator;
+    public function base(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
 
     public function base64(): ChainedValidator;
 
-    public function between(mixed $minimum, mixed $maximum): ChainedValidator;
+    public function between(mixed $minValue, mixed $maxValue): ChainedValidator;
 
     public function betweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
 
@@ -54,7 +59,7 @@ interface ChainedValidator extends Validatable
 
     public function callableType(): ChainedValidator;
 
-    public function callback(callable $callback): ChainedValidator;
+    public function callback(callable $callback, mixed ...$arguments): ChainedValidator;
 
     public function charset(string $charset, string ...$charsets): ChainedValidator;
 
@@ -62,28 +67,34 @@ interface ChainedValidator extends Validatable
 
     public function cnpj(): ChainedValidator;
 
-    public function consecutive(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
-
-    public function control(string ...$additionalChars): ChainedValidator;
+    public function consecutive(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public function consonant(string ...$additionalChars): ChainedValidator;
 
     public function contains(mixed $containsValue, bool $identical = false): ChainedValidator;
 
-    /** @param non-empty-array<mixed> $needles */
-    public function containsAny(array $needles, bool $strictCompareArray = false): ChainedValidator;
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public function containsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public function control(string ...$additionalChars): ChainedValidator;
 
     public function countable(): ChainedValidator;
 
-    /** @param "alpha-2"|"alpha-3"|"numeric" $set */
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
     public function countryCode(string $set = 'alpha-2'): ChainedValidator;
 
-    /** @param "alpha-3"|"numeric" $set */
-    public function currencyCode(string $set = 'alpha-3'): ChainedValidator;
-
     public function cpf(): ChainedValidator;
 
-    public function creditCard(?string $brand = null): ChainedValidator;
+    public function creditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public function currencyCode(string $set = 'alpha-3'): ChainedValidator;
 
     public function date(string $format = 'Y-m-d'): ChainedValidator;
 
@@ -123,21 +134,20 @@ interface ChainedValidator extends Validatable
 
     public function file(): ChainedValidator;
 
-    /**
-     * @param mixed[]|int $options
-     */
-    public function filterVar(int $filter, array|int|null $options = null): ChainedValidator;
+    public function filterVar(int $filter, mixed $options = null): ChainedValidator;
 
     public function finite(): ChainedValidator;
 
-    public function floatVal(): ChainedValidator;
-
     public function floatType(): ChainedValidator;
 
+    public function floatVal(): ChainedValidator;
+
     public function graph(string ...$additionalChars): ChainedValidator;
 
     public function greaterThan(mixed $compareTo): ChainedValidator;
 
+    public function greaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
     public function hetu(): ChainedValidator;
 
     public function hexRgbColor(): ChainedValidator;
@@ -146,7 +156,7 @@ interface ChainedValidator extends Validatable
 
     public function identical(mixed $compareTo): ChainedValidator;
 
-    public function image(?finfo $fileInfo = null): ChainedValidator;
+    public function image(): ChainedValidator;
 
     public function imei(): ChainedValidator;
 
@@ -154,12 +164,15 @@ interface ChainedValidator extends Validatable
 
     public function infinite(): ChainedValidator;
 
-    public function instance(string $instanceName): ChainedValidator;
-
-    public function intVal(): ChainedValidator;
+    /**
+     * @param class-string $class
+     */
+    public function instance(string $class): ChainedValidator;
 
     public function intType(): ChainedValidator;
 
+    public function intVal(): ChainedValidator;
+
     public function ip(string $range = '*', ?int $options = null): ChainedValidator;
 
     public function isbn(): ChainedValidator;
@@ -170,45 +183,47 @@ interface ChainedValidator extends Validatable
 
     public function json(): ChainedValidator;
 
-    public function key(int|string $key, Validatable $rule): ChainedValidator;
+    public function key(string|int $key, Validatable $rule): ChainedValidator;
 
-    public function keyExists(int|string $key): ChainedValidator;
+    public function keyExists(string|int $key): ChainedValidator;
 
-    public function keyOptional(int|string $key, Validatable $rule): ChainedValidator;
+    public function keyOptional(string|int $key, Validatable $rule): ChainedValidator;
 
     public function keySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
 
-    /** @param callable(mixed): Validatable $ruleCreator */
-    public function lazy(callable $ruleCreator): ChainedValidator;
-
-    /** @param "alpha-2"|"alpha-3" $set */
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
     public function languageCode(string $set = 'alpha-2'): ChainedValidator;
 
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public function lazy(callable $ruleCreator): ChainedValidator;
+
     public function leapDate(string $format): ChainedValidator;
 
     public function leapYear(): ChainedValidator;
 
     public function length(Validatable $rule): ChainedValidator;
 
-    public function lowercase(): ChainedValidator;
-
     public function lessThan(mixed $compareTo): ChainedValidator;
 
+    public function lessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public function lowercase(): ChainedValidator;
+
     public function luhn(): ChainedValidator;
 
     public function macAddress(): ChainedValidator;
 
-    public function lessThanOrEqual(mixed $compareTo): ChainedValidator;
-
     public function max(Validatable $rule): ChainedValidator;
 
     public function maxAge(int $age, ?string $format = null): ChainedValidator;
 
-    public function min(Validatable $rule): ChainedValidator;
-
     public function mimetype(string $mimetype): ChainedValidator;
 
-    public function greaterThanOrEqual(mixed $compareTo): ChainedValidator;
+    public function min(Validatable $rule): ChainedValidator;
 
     public function minAge(int $age, ?string $format = null): ChainedValidator;
 
@@ -224,7 +239,9 @@ interface ChainedValidator extends Validatable
 
     public function no(bool $useLocale = false): ChainedValidator;
 
-    public function noneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public function noWhitespace(): ChainedValidator;
+
+    public function noneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public function not(Validatable $rule): ChainedValidator;
 
@@ -236,12 +253,10 @@ interface ChainedValidator extends Validatable
 
     public function notOptional(): ChainedValidator;
 
-    public function noWhitespace(): ChainedValidator;
+    public function nullType(): ChainedValidator;
 
     public function nullable(Validatable $rule): ChainedValidator;
 
-    public function nullType(): ChainedValidator;
-
     public function number(): ChainedValidator;
 
     public function numericVal(): ChainedValidator;
@@ -250,7 +265,7 @@ interface ChainedValidator extends Validatable
 
     public function odd(): ChainedValidator;
 
-    public function oneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public function oneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public function optional(Validatable $rule): ChainedValidator;
 
@@ -270,12 +285,18 @@ interface ChainedValidator extends Validatable
 
     public function positive(): ChainedValidator;
 
-    public function postalCode(string $countryCode): ChainedValidator;
+    public function postalCode(string $countryCode, bool $formatted = false): ChainedValidator;
 
     public function primeNumber(): ChainedValidator;
 
     public function printable(string ...$additionalChars): ChainedValidator;
 
+    public function property(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public function propertyExists(string $propertyName): ChainedValidator;
+
+    public function propertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
     public function publicDomainSuffix(): ChainedValidator;
 
     public function punct(string ...$additionalChars): ChainedValidator;
@@ -290,7 +311,7 @@ interface ChainedValidator extends Validatable
 
     public function scalarVal(): ChainedValidator;
 
-    public function size(?string $minSize = null, ?string $maxSize = null): ChainedValidator;
+    public function size(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
 
     public function slug(): ChainedValidator;
 
@@ -319,8 +340,6 @@ interface ChainedValidator extends Validatable
 
     public function trueVal(): ChainedValidator;
 
-    public function type(string $type): ChainedValidator;
-
     public function unique(): ChainedValidator;
 
     public function uploaded(): ChainedValidator;
@@ -337,14 +356,11 @@ interface ChainedValidator extends Validatable
 
     public function vowel(string ...$additionalChars): ChainedValidator;
 
-    public function when(Validatable $if, Validatable $then, ?Validatable $else = null): ChainedValidator;
+    public function when(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
 
     public function writable(): ChainedValidator;
 
     public function xdigit(string ...$additionalChars): ChainedValidator;
 
     public function yes(bool $useLocale = false): ChainedValidator;
-
-    /** @param array<string, mixed> $templates */
-    public function setTemplates(array $templates): ChainedValidator;
 }
diff --git a/library/Mixins/StaticKey.php b/library/Mixins/StaticKey.php
new file mode 100644
index 00000000..fc6d6cc3
--- /dev/null
+++ b/library/Mixins/StaticKey.php
@@ -0,0 +1,388 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface StaticKey
+{
+    public static function keyAllOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function keyAlnum(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyAlpha(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyAlwaysInvalid(int|string $key): ChainedValidator;
+
+    public static function keyAlwaysValid(int|string $key): ChainedValidator;
+
+    public static function keyAnyOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function keyArrayType(int|string $key): ChainedValidator;
+
+    public static function keyArrayVal(int|string $key): ChainedValidator;
+
+    public static function keyBase(
+        int|string $key,
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public static function keyBase64(int|string $key): ChainedValidator;
+
+    public static function keyBetween(int|string $key, mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function keyBetweenExclusive(int|string $key, mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function keyBoolType(int|string $key): ChainedValidator;
+
+    public static function keyBoolVal(int|string $key): ChainedValidator;
+
+    public static function keyBsn(int|string $key): ChainedValidator;
+
+    public static function keyCall(int|string $key, callable $callable, Validatable $rule): ChainedValidator;
+
+    public static function keyCallableType(int|string $key): ChainedValidator;
+
+    public static function keyCallback(int|string $key, callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public static function keyCharset(int|string $key, string $charset, string ...$charsets): ChainedValidator;
+
+    public static function keyCnh(int|string $key): ChainedValidator;
+
+    public static function keyCnpj(int|string $key): ChainedValidator;
+
+    public static function keyConsecutive(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function keyConsonant(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyContains(
+        int|string $key,
+        mixed $containsValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function keyContainsAny(int|string $key, array $needles, bool $identical = false): ChainedValidator;
+
+    public static function keyControl(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyCountable(int|string $key): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public static function keyCountryCode(int|string $key, string $set = 'alpha-2'): ChainedValidator;
+
+    public static function keyCpf(int|string $key): ChainedValidator;
+
+    public static function keyCreditCard(int|string $key, string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function keyCurrencyCode(int|string $key, string $set = 'alpha-3'): ChainedValidator;
+
+    public static function keyDate(int|string $key, string $format = 'Y-m-d'): ChainedValidator;
+
+    public static function keyDateTime(int|string $key, ?string $format = null): ChainedValidator;
+
+    public static function keyDecimal(int|string $key, int $decimals): ChainedValidator;
+
+    public static function keyDigit(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyDirectory(int|string $key): ChainedValidator;
+
+    public static function keyDomain(int|string $key, bool $tldCheck = true): ChainedValidator;
+
+    public static function keyEach(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyEmail(int|string $key): ChainedValidator;
+
+    public static function keyEndsWith(int|string $key, mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public static function keyEquals(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyEquivalent(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyEven(int|string $key): ChainedValidator;
+
+    public static function keyExecutable(int|string $key): ChainedValidator;
+
+    public static function keyExtension(int|string $key, string $extension): ChainedValidator;
+
+    public static function keyFactor(int|string $key, int $dividend): ChainedValidator;
+
+    public static function keyFalseVal(int|string $key): ChainedValidator;
+
+    public static function keyFibonacci(int|string $key): ChainedValidator;
+
+    public static function keyFile(int|string $key): ChainedValidator;
+
+    public static function keyFilterVar(int|string $key, int $filter, mixed $options = null): ChainedValidator;
+
+    public static function keyFinite(int|string $key): ChainedValidator;
+
+    public static function keyFloatType(int|string $key): ChainedValidator;
+
+    public static function keyFloatVal(int|string $key): ChainedValidator;
+
+    public static function keyGraph(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyGreaterThan(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyGreaterThanOrEqual(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyHetu(int|string $key): ChainedValidator;
+
+    public static function keyHexRgbColor(int|string $key): ChainedValidator;
+
+    public static function keyIban(int|string $key): ChainedValidator;
+
+    public static function keyIdentical(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyImage(int|string $key): ChainedValidator;
+
+    public static function keyImei(int|string $key): ChainedValidator;
+
+    public static function keyIn(int|string $key, mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function keyInfinite(int|string $key): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public static function keyInstance(int|string $key, string $class): ChainedValidator;
+
+    public static function keyIntType(int|string $key): ChainedValidator;
+
+    public static function keyIntVal(int|string $key): ChainedValidator;
+
+    public static function keyIp(int|string $key, string $range = '*', ?int $options = null): ChainedValidator;
+
+    public static function keyIsbn(int|string $key): ChainedValidator;
+
+    public static function keyIterableType(int|string $key): ChainedValidator;
+
+    public static function keyIterableVal(int|string $key): ChainedValidator;
+
+    public static function keyJson(int|string $key): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public static function keyLanguageCode(int|string $key, string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function keyLazy(int|string $key, callable $ruleCreator): ChainedValidator;
+
+    public static function keyLeapDate(int|string $key, string $format): ChainedValidator;
+
+    public static function keyLeapYear(int|string $key): ChainedValidator;
+
+    public static function keyLength(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyLessThan(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyLessThanOrEqual(int|string $key, mixed $compareTo): ChainedValidator;
+
+    public static function keyLowercase(int|string $key): ChainedValidator;
+
+    public static function keyLuhn(int|string $key): ChainedValidator;
+
+    public static function keyMacAddress(int|string $key): ChainedValidator;
+
+    public static function keyMax(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyMaxAge(int|string $key, int $age, ?string $format = null): ChainedValidator;
+
+    public static function keyMimetype(int|string $key, string $mimetype): ChainedValidator;
+
+    public static function keyMin(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyMinAge(int|string $key, int $age, ?string $format = null): ChainedValidator;
+
+    public static function keyMultiple(int|string $key, int $multipleOf): ChainedValidator;
+
+    public static function keyNegative(int|string $key): ChainedValidator;
+
+    public static function keyNfeAccessKey(int|string $key): ChainedValidator;
+
+    public static function keyNif(int|string $key): ChainedValidator;
+
+    public static function keyNip(int|string $key): ChainedValidator;
+
+    public static function keyNo(int|string $key, bool $useLocale = false): ChainedValidator;
+
+    public static function keyNoWhitespace(int|string $key): ChainedValidator;
+
+    public static function keyNoneOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function keyNot(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyNotBlank(int|string $key): ChainedValidator;
+
+    public static function keyNotEmoji(int|string $key): ChainedValidator;
+
+    public static function keyNotEmpty(int|string $key): ChainedValidator;
+
+    public static function keyNotOptional(int|string $key): ChainedValidator;
+
+    public static function keyNullType(int|string $key): ChainedValidator;
+
+    public static function keyNullable(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyNumber(int|string $key): ChainedValidator;
+
+    public static function keyNumericVal(int|string $key): ChainedValidator;
+
+    public static function keyObjectType(int|string $key): ChainedValidator;
+
+    public static function keyOdd(int|string $key): ChainedValidator;
+
+    public static function keyOneOf(
+        int|string $key,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function keyOptional(int|string $key, Validatable $rule): ChainedValidator;
+
+    public static function keyPerfectSquare(int|string $key): ChainedValidator;
+
+    public static function keyPesel(int|string $key): ChainedValidator;
+
+    public static function keyPhone(int|string $key, ?string $countryCode = null): ChainedValidator;
+
+    public static function keyPhpLabel(int|string $key): ChainedValidator;
+
+    public static function keyPis(int|string $key): ChainedValidator;
+
+    public static function keyPolishIdCard(int|string $key): ChainedValidator;
+
+    public static function keyPortugueseNif(int|string $key): ChainedValidator;
+
+    public static function keyPositive(int|string $key): ChainedValidator;
+
+    public static function keyPostalCode(
+        int|string $key,
+        string $countryCode,
+        bool $formatted = false,
+    ): ChainedValidator;
+
+    public static function keyPrimeNumber(int|string $key): ChainedValidator;
+
+    public static function keyPrintable(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyPublicDomainSuffix(int|string $key): ChainedValidator;
+
+    public static function keyPunct(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyReadable(int|string $key): ChainedValidator;
+
+    public static function keyRegex(int|string $key, string $regex): ChainedValidator;
+
+    public static function keyResourceType(int|string $key): ChainedValidator;
+
+    public static function keyRoman(int|string $key): ChainedValidator;
+
+    public static function keyScalarVal(int|string $key): ChainedValidator;
+
+    public static function keySize(
+        int|string $key,
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public static function keySlug(int|string $key): ChainedValidator;
+
+    public static function keySorted(int|string $key, string $direction): ChainedValidator;
+
+    public static function keySpace(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyStartsWith(
+        int|string $key,
+        mixed $startValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public static function keyStringType(int|string $key): ChainedValidator;
+
+    public static function keyStringVal(int|string $key): ChainedValidator;
+
+    public static function keySubdivisionCode(int|string $key, string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public static function keySubset(int|string $key, array $superset): ChainedValidator;
+
+    public static function keySymbolicLink(int|string $key): ChainedValidator;
+
+    public static function keyTime(int|string $key, string $format = 'H:i:s'): ChainedValidator;
+
+    public static function keyTld(int|string $key): ChainedValidator;
+
+    public static function keyTrueVal(int|string $key): ChainedValidator;
+
+    public static function keyUnique(int|string $key): ChainedValidator;
+
+    public static function keyUploaded(int|string $key): ChainedValidator;
+
+    public static function keyUppercase(int|string $key): ChainedValidator;
+
+    public static function keyUrl(int|string $key): ChainedValidator;
+
+    public static function keyUuid(int|string $key, ?int $version = null): ChainedValidator;
+
+    public static function keyVersion(int|string $key): ChainedValidator;
+
+    public static function keyVideoUrl(int|string $key, ?string $service = null): ChainedValidator;
+
+    public static function keyVowel(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyWhen(
+        int|string $key,
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public static function keyWritable(int|string $key): ChainedValidator;
+
+    public static function keyXdigit(int|string $key, string ...$additionalChars): ChainedValidator;
+
+    public static function keyYes(int|string $key, bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/StaticLength.php b/library/Mixins/StaticLength.php
new file mode 100644
index 00000000..dabca825
--- /dev/null
+++ b/library/Mixins/StaticLength.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface StaticLength
+{
+    public static function lengthBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function lengthBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function lengthEquals(mixed $compareTo): ChainedValidator;
+
+    public static function lengthEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function lengthEven(): ChainedValidator;
+
+    public static function lengthFactor(int $dividend): ChainedValidator;
+
+    public static function lengthFibonacci(): ChainedValidator;
+
+    public static function lengthFinite(): ChainedValidator;
+
+    public static function lengthGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function lengthGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function lengthIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function lengthIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function lengthInfinite(): ChainedValidator;
+
+    public static function lengthLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function lengthLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function lengthMultiple(int $multipleOf): ChainedValidator;
+
+    public static function lengthOdd(): ChainedValidator;
+
+    public static function lengthPerfectSquare(): ChainedValidator;
+
+    public static function lengthPositive(): ChainedValidator;
+
+    public static function lengthPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/StaticMax.php b/library/Mixins/StaticMax.php
new file mode 100644
index 00000000..7090e1b4
--- /dev/null
+++ b/library/Mixins/StaticMax.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface StaticMax
+{
+    public static function maxBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function maxBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function maxEquals(mixed $compareTo): ChainedValidator;
+
+    public static function maxEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function maxEven(): ChainedValidator;
+
+    public static function maxFactor(int $dividend): ChainedValidator;
+
+    public static function maxFibonacci(): ChainedValidator;
+
+    public static function maxFinite(): ChainedValidator;
+
+    public static function maxGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function maxGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function maxIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function maxIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function maxInfinite(): ChainedValidator;
+
+    public static function maxLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function maxLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function maxMultiple(int $multipleOf): ChainedValidator;
+
+    public static function maxOdd(): ChainedValidator;
+
+    public static function maxPerfectSquare(): ChainedValidator;
+
+    public static function maxPositive(): ChainedValidator;
+
+    public static function maxPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/StaticMin.php b/library/Mixins/StaticMin.php
new file mode 100644
index 00000000..68ba9894
--- /dev/null
+++ b/library/Mixins/StaticMin.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+interface StaticMin
+{
+    public static function minBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function minBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function minEquals(mixed $compareTo): ChainedValidator;
+
+    public static function minEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function minEven(): ChainedValidator;
+
+    public static function minFactor(int $dividend): ChainedValidator;
+
+    public static function minFibonacci(): ChainedValidator;
+
+    public static function minFinite(): ChainedValidator;
+
+    public static function minGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function minGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function minIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function minIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function minInfinite(): ChainedValidator;
+
+    public static function minLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function minLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function minMultiple(int $multipleOf): ChainedValidator;
+
+    public static function minOdd(): ChainedValidator;
+
+    public static function minPerfectSquare(): ChainedValidator;
+
+    public static function minPositive(): ChainedValidator;
+
+    public static function minPrimeNumber(): ChainedValidator;
+}
diff --git a/library/Mixins/StaticNot.php b/library/Mixins/StaticNot.php
new file mode 100644
index 00000000..d5442a3a
--- /dev/null
+++ b/library/Mixins/StaticNot.php
@@ -0,0 +1,349 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface StaticNot
+{
+    public static function notAllOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public static function notAlnum(string ...$additionalChars): ChainedValidator;
+
+    public static function notAlpha(string ...$additionalChars): ChainedValidator;
+
+    public static function notAlwaysInvalid(): ChainedValidator;
+
+    public static function notAlwaysValid(): ChainedValidator;
+
+    public static function notAnyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public static function notArrayType(): ChainedValidator;
+
+    public static function notArrayVal(): ChainedValidator;
+
+    public static function notBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public static function notBase64(): ChainedValidator;
+
+    public static function notBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function notBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function notBoolType(): ChainedValidator;
+
+    public static function notBoolVal(): ChainedValidator;
+
+    public static function notBsn(): ChainedValidator;
+
+    public static function notCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public static function notCallableType(): ChainedValidator;
+
+    public static function notCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public static function notCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public static function notCnh(): ChainedValidator;
+
+    public static function notCnpj(): ChainedValidator;
+
+    public static function notConsecutive(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function notConsonant(string ...$additionalChars): ChainedValidator;
+
+    public static function notContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function notContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public static function notControl(string ...$additionalChars): ChainedValidator;
+
+    public static function notCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public static function notCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public static function notCpf(): ChainedValidator;
+
+    public static function notCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function notCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public static function notDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public static function notDateTime(?string $format = null): ChainedValidator;
+
+    public static function notDecimal(int $decimals): ChainedValidator;
+
+    public static function notDigit(string ...$additionalChars): ChainedValidator;
+
+    public static function notDirectory(): ChainedValidator;
+
+    public static function notDomain(bool $tldCheck = true): ChainedValidator;
+
+    public static function notEach(Validatable $rule): ChainedValidator;
+
+    public static function notEmail(): ChainedValidator;
+
+    public static function notEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public static function notEquals(mixed $compareTo): ChainedValidator;
+
+    public static function notEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function notEven(): ChainedValidator;
+
+    public static function notExecutable(): ChainedValidator;
+
+    public static function notExists(): ChainedValidator;
+
+    public static function notExtension(string $extension): ChainedValidator;
+
+    public static function notFactor(int $dividend): ChainedValidator;
+
+    public static function notFalseVal(): ChainedValidator;
+
+    public static function notFibonacci(): ChainedValidator;
+
+    public static function notFile(): ChainedValidator;
+
+    public static function notFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public static function notFinite(): ChainedValidator;
+
+    public static function notFloatType(): ChainedValidator;
+
+    public static function notFloatVal(): ChainedValidator;
+
+    public static function notGraph(string ...$additionalChars): ChainedValidator;
+
+    public static function notGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function notGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function notHetu(): ChainedValidator;
+
+    public static function notHexRgbColor(): ChainedValidator;
+
+    public static function notIban(): ChainedValidator;
+
+    public static function notIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function notImage(): ChainedValidator;
+
+    public static function notImei(): ChainedValidator;
+
+    public static function notIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function notInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public static function notInstance(string $class): ChainedValidator;
+
+    public static function notIntType(): ChainedValidator;
+
+    public static function notIntVal(): ChainedValidator;
+
+    public static function notIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public static function notIsbn(): ChainedValidator;
+
+    public static function notIterableType(): ChainedValidator;
+
+    public static function notIterableVal(): ChainedValidator;
+
+    public static function notJson(): ChainedValidator;
+
+    public static function notKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function notKeyExists(string|int $key): ChainedValidator;
+
+    public static function notKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function notKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public static function notLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function notLazy(callable $ruleCreator): ChainedValidator;
+
+    public static function notLeapDate(string $format): ChainedValidator;
+
+    public static function notLeapYear(): ChainedValidator;
+
+    public static function notLength(Validatable $rule): ChainedValidator;
+
+    public static function notLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function notLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function notLowercase(): ChainedValidator;
+
+    public static function notLuhn(): ChainedValidator;
+
+    public static function notMacAddress(): ChainedValidator;
+
+    public static function notMax(Validatable $rule): ChainedValidator;
+
+    public static function notMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function notMimetype(string $mimetype): ChainedValidator;
+
+    public static function notMin(Validatable $rule): ChainedValidator;
+
+    public static function notMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function notMultiple(int $multipleOf): ChainedValidator;
+
+    public static function notNegative(): ChainedValidator;
+
+    public static function notNfeAccessKey(): ChainedValidator;
+
+    public static function notNif(): ChainedValidator;
+
+    public static function notNip(): ChainedValidator;
+
+    public static function notNo(bool $useLocale = false): ChainedValidator;
+
+    public static function notNoWhitespace(): ChainedValidator;
+
+    public static function notNoneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public static function notNullType(): ChainedValidator;
+
+    public static function notNullable(Validatable $rule): ChainedValidator;
+
+    public static function notNumber(): ChainedValidator;
+
+    public static function notNumericVal(): ChainedValidator;
+
+    public static function notObjectType(): ChainedValidator;
+
+    public static function notOdd(): ChainedValidator;
+
+    public static function notOneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
+
+    public static function notPerfectSquare(): ChainedValidator;
+
+    public static function notPesel(): ChainedValidator;
+
+    public static function notPhone(?string $countryCode = null): ChainedValidator;
+
+    public static function notPhpLabel(): ChainedValidator;
+
+    public static function notPis(): ChainedValidator;
+
+    public static function notPolishIdCard(): ChainedValidator;
+
+    public static function notPortugueseNif(): ChainedValidator;
+
+    public static function notPositive(): ChainedValidator;
+
+    public static function notPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public static function notPrimeNumber(): ChainedValidator;
+
+    public static function notPrintable(string ...$additionalChars): ChainedValidator;
+
+    public static function notProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function notPropertyExists(string $propertyName): ChainedValidator;
+
+    public static function notPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function notPublicDomainSuffix(): ChainedValidator;
+
+    public static function notPunct(string ...$additionalChars): ChainedValidator;
+
+    public static function notReadable(): ChainedValidator;
+
+    public static function notRegex(string $regex): ChainedValidator;
+
+    public static function notResourceType(): ChainedValidator;
+
+    public static function notRoman(): ChainedValidator;
+
+    public static function notScalarVal(): ChainedValidator;
+
+    public static function notSize(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
+
+    public static function notSlug(): ChainedValidator;
+
+    public static function notSorted(string $direction): ChainedValidator;
+
+    public static function notSpace(string ...$additionalChars): ChainedValidator;
+
+    public static function notStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public static function notStringType(): ChainedValidator;
+
+    public static function notStringVal(): ChainedValidator;
+
+    public static function notSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public static function notSubset(array $superset): ChainedValidator;
+
+    public static function notSymbolicLink(): ChainedValidator;
+
+    public static function notTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public static function notTld(): ChainedValidator;
+
+    public static function notTrueVal(): ChainedValidator;
+
+    public static function notUnique(): ChainedValidator;
+
+    public static function notUploaded(): ChainedValidator;
+
+    public static function notUppercase(): ChainedValidator;
+
+    public static function notUrl(): ChainedValidator;
+
+    public static function notUuid(?int $version = null): ChainedValidator;
+
+    public static function notVersion(): ChainedValidator;
+
+    public static function notVideoUrl(?string $service = null): ChainedValidator;
+
+    public static function notVowel(string ...$additionalChars): ChainedValidator;
+
+    public static function notWhen(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
+
+    public static function notWritable(): ChainedValidator;
+
+    public static function notXdigit(string ...$additionalChars): ChainedValidator;
+
+    public static function notYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/StaticNullOr.php b/library/Mixins/StaticNullOr.php
new file mode 100644
index 00000000..5eb7431e
--- /dev/null
+++ b/library/Mixins/StaticNullOr.php
@@ -0,0 +1,380 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface StaticNullOr
+{
+    public static function nullOfAllOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function nullOfAlnum(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfAlpha(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfAlwaysInvalid(): ChainedValidator;
+
+    public static function nullOfAlwaysValid(): ChainedValidator;
+
+    public static function nullOfAnyOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function nullOfArrayType(): ChainedValidator;
+
+    public static function nullOfArrayVal(): ChainedValidator;
+
+    public static function nullOfBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public static function nullOfBase64(): ChainedValidator;
+
+    public static function nullOfBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function nullOfBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function nullOfBoolType(): ChainedValidator;
+
+    public static function nullOfBoolVal(): ChainedValidator;
+
+    public static function nullOfBsn(): ChainedValidator;
+
+    public static function nullOfCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public static function nullOfCallableType(): ChainedValidator;
+
+    public static function nullOfCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public static function nullOfCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public static function nullOfCnh(): ChainedValidator;
+
+    public static function nullOfCnpj(): ChainedValidator;
+
+    public static function nullOfConsecutive(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function nullOfConsonant(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function nullOfContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public static function nullOfControl(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public static function nullOfCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public static function nullOfCpf(): ChainedValidator;
+
+    public static function nullOfCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function nullOfCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public static function nullOfDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public static function nullOfDateTime(?string $format = null): ChainedValidator;
+
+    public static function nullOfDecimal(int $decimals): ChainedValidator;
+
+    public static function nullOfDigit(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfDirectory(): ChainedValidator;
+
+    public static function nullOfDomain(bool $tldCheck = true): ChainedValidator;
+
+    public static function nullOfEach(Validatable $rule): ChainedValidator;
+
+    public static function nullOfEmail(): ChainedValidator;
+
+    public static function nullOfEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public static function nullOfEquals(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfEven(): ChainedValidator;
+
+    public static function nullOfExecutable(): ChainedValidator;
+
+    public static function nullOfExists(): ChainedValidator;
+
+    public static function nullOfExtension(string $extension): ChainedValidator;
+
+    public static function nullOfFactor(int $dividend): ChainedValidator;
+
+    public static function nullOfFalseVal(): ChainedValidator;
+
+    public static function nullOfFibonacci(): ChainedValidator;
+
+    public static function nullOfFile(): ChainedValidator;
+
+    public static function nullOfFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public static function nullOfFinite(): ChainedValidator;
+
+    public static function nullOfFloatType(): ChainedValidator;
+
+    public static function nullOfFloatVal(): ChainedValidator;
+
+    public static function nullOfGraph(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfHetu(): ChainedValidator;
+
+    public static function nullOfHexRgbColor(): ChainedValidator;
+
+    public static function nullOfIban(): ChainedValidator;
+
+    public static function nullOfIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfImage(): ChainedValidator;
+
+    public static function nullOfImei(): ChainedValidator;
+
+    public static function nullOfIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function nullOfInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public static function nullOfInstance(string $class): ChainedValidator;
+
+    public static function nullOfIntType(): ChainedValidator;
+
+    public static function nullOfIntVal(): ChainedValidator;
+
+    public static function nullOfIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public static function nullOfIsbn(): ChainedValidator;
+
+    public static function nullOfIterableType(): ChainedValidator;
+
+    public static function nullOfIterableVal(): ChainedValidator;
+
+    public static function nullOfJson(): ChainedValidator;
+
+    public static function nullOfKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function nullOfKeyExists(string|int $key): ChainedValidator;
+
+    public static function nullOfKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function nullOfKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public static function nullOfLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function nullOfLazy(callable $ruleCreator): ChainedValidator;
+
+    public static function nullOfLeapDate(string $format): ChainedValidator;
+
+    public static function nullOfLeapYear(): ChainedValidator;
+
+    public static function nullOfLength(Validatable $rule): ChainedValidator;
+
+    public static function nullOfLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function nullOfLowercase(): ChainedValidator;
+
+    public static function nullOfLuhn(): ChainedValidator;
+
+    public static function nullOfMacAddress(): ChainedValidator;
+
+    public static function nullOfMax(Validatable $rule): ChainedValidator;
+
+    public static function nullOfMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function nullOfMimetype(string $mimetype): ChainedValidator;
+
+    public static function nullOfMin(Validatable $rule): ChainedValidator;
+
+    public static function nullOfMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function nullOfMultiple(int $multipleOf): ChainedValidator;
+
+    public static function nullOfNegative(): ChainedValidator;
+
+    public static function nullOfNfeAccessKey(): ChainedValidator;
+
+    public static function nullOfNif(): ChainedValidator;
+
+    public static function nullOfNip(): ChainedValidator;
+
+    public static function nullOfNo(bool $useLocale = false): ChainedValidator;
+
+    public static function nullOfNoWhitespace(): ChainedValidator;
+
+    public static function nullOfNoneOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function nullOfNot(Validatable $rule): ChainedValidator;
+
+    public static function nullOfNotBlank(): ChainedValidator;
+
+    public static function nullOfNotEmoji(): ChainedValidator;
+
+    public static function nullOfNotEmpty(): ChainedValidator;
+
+    public static function nullOfNotOptional(): ChainedValidator;
+
+    public static function nullOfNullType(): ChainedValidator;
+
+    public static function nullOfNumber(): ChainedValidator;
+
+    public static function nullOfNumericVal(): ChainedValidator;
+
+    public static function nullOfObjectType(): ChainedValidator;
+
+    public static function nullOfOdd(): ChainedValidator;
+
+    public static function nullOfOneOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function nullOfPerfectSquare(): ChainedValidator;
+
+    public static function nullOfPesel(): ChainedValidator;
+
+    public static function nullOfPhone(?string $countryCode = null): ChainedValidator;
+
+    public static function nullOfPhpLabel(): ChainedValidator;
+
+    public static function nullOfPis(): ChainedValidator;
+
+    public static function nullOfPolishIdCard(): ChainedValidator;
+
+    public static function nullOfPortugueseNif(): ChainedValidator;
+
+    public static function nullOfPositive(): ChainedValidator;
+
+    public static function nullOfPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public static function nullOfPrimeNumber(): ChainedValidator;
+
+    public static function nullOfPrintable(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function nullOfPropertyExists(string $propertyName): ChainedValidator;
+
+    public static function nullOfPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function nullOfPublicDomainSuffix(): ChainedValidator;
+
+    public static function nullOfPunct(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfReadable(): ChainedValidator;
+
+    public static function nullOfRegex(string $regex): ChainedValidator;
+
+    public static function nullOfResourceType(): ChainedValidator;
+
+    public static function nullOfRoman(): ChainedValidator;
+
+    public static function nullOfScalarVal(): ChainedValidator;
+
+    public static function nullOfSize(
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public static function nullOfSlug(): ChainedValidator;
+
+    public static function nullOfSorted(string $direction): ChainedValidator;
+
+    public static function nullOfSpace(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public static function nullOfStringType(): ChainedValidator;
+
+    public static function nullOfStringVal(): ChainedValidator;
+
+    public static function nullOfSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public static function nullOfSubset(array $superset): ChainedValidator;
+
+    public static function nullOfSymbolicLink(): ChainedValidator;
+
+    public static function nullOfTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public static function nullOfTld(): ChainedValidator;
+
+    public static function nullOfTrueVal(): ChainedValidator;
+
+    public static function nullOfUnique(): ChainedValidator;
+
+    public static function nullOfUploaded(): ChainedValidator;
+
+    public static function nullOfUppercase(): ChainedValidator;
+
+    public static function nullOfUrl(): ChainedValidator;
+
+    public static function nullOfUuid(?int $version = null): ChainedValidator;
+
+    public static function nullOfVersion(): ChainedValidator;
+
+    public static function nullOfVideoUrl(?string $service = null): ChainedValidator;
+
+    public static function nullOfVowel(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfWhen(
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public static function nullOfWritable(): ChainedValidator;
+
+    public static function nullOfXdigit(string ...$additionalChars): ChainedValidator;
+
+    public static function nullOfYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/StaticProperty.php b/library/Mixins/StaticProperty.php
new file mode 100644
index 00000000..ed80fe9e
--- /dev/null
+++ b/library/Mixins/StaticProperty.php
@@ -0,0 +1,420 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface StaticProperty
+{
+    public static function propertyAllOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function propertyAlnum(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyAlpha(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyAlwaysInvalid(string $propertyName): ChainedValidator;
+
+    public static function propertyAlwaysValid(string $propertyName): ChainedValidator;
+
+    public static function propertyAnyOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function propertyArrayType(string $propertyName): ChainedValidator;
+
+    public static function propertyArrayVal(string $propertyName): ChainedValidator;
+
+    public static function propertyBase(
+        string $propertyName,
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public static function propertyBase64(string $propertyName): ChainedValidator;
+
+    public static function propertyBetween(string $propertyName, mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function propertyBetweenExclusive(
+        string $propertyName,
+        mixed $minimum,
+        mixed $maximum,
+    ): ChainedValidator;
+
+    public static function propertyBoolType(string $propertyName): ChainedValidator;
+
+    public static function propertyBoolVal(string $propertyName): ChainedValidator;
+
+    public static function propertyBsn(string $propertyName): ChainedValidator;
+
+    public static function propertyCall(string $propertyName, callable $callable, Validatable $rule): ChainedValidator;
+
+    public static function propertyCallableType(string $propertyName): ChainedValidator;
+
+    public static function propertyCallback(
+        string $propertyName,
+        callable $callback,
+        mixed ...$arguments,
+    ): ChainedValidator;
+
+    public static function propertyCharset(
+        string $propertyName,
+        string $charset,
+        string ...$charsets,
+    ): ChainedValidator;
+
+    public static function propertyCnh(string $propertyName): ChainedValidator;
+
+    public static function propertyCnpj(string $propertyName): ChainedValidator;
+
+    public static function propertyConsecutive(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function propertyConsonant(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyContains(
+        string $propertyName,
+        mixed $containsValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function propertyContainsAny(
+        string $propertyName,
+        array $needles,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public static function propertyControl(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyCountable(string $propertyName): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public static function propertyCountryCode(string $propertyName, string $set = 'alpha-2'): ChainedValidator;
+
+    public static function propertyCpf(string $propertyName): ChainedValidator;
+
+    public static function propertyCreditCard(string $propertyName, string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function propertyCurrencyCode(string $propertyName, string $set = 'alpha-3'): ChainedValidator;
+
+    public static function propertyDate(string $propertyName, string $format = 'Y-m-d'): ChainedValidator;
+
+    public static function propertyDateTime(string $propertyName, ?string $format = null): ChainedValidator;
+
+    public static function propertyDecimal(string $propertyName, int $decimals): ChainedValidator;
+
+    public static function propertyDigit(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyDirectory(string $propertyName): ChainedValidator;
+
+    public static function propertyDomain(string $propertyName, bool $tldCheck = true): ChainedValidator;
+
+    public static function propertyEach(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyEmail(string $propertyName): ChainedValidator;
+
+    public static function propertyEndsWith(
+        string $propertyName,
+        mixed $endValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public static function propertyEquals(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyEquivalent(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyEven(string $propertyName): ChainedValidator;
+
+    public static function propertyExecutable(string $propertyName): ChainedValidator;
+
+    public static function propertyExtension(string $propertyName, string $extension): ChainedValidator;
+
+    public static function propertyFactor(string $propertyName, int $dividend): ChainedValidator;
+
+    public static function propertyFalseVal(string $propertyName): ChainedValidator;
+
+    public static function propertyFibonacci(string $propertyName): ChainedValidator;
+
+    public static function propertyFile(string $propertyName): ChainedValidator;
+
+    public static function propertyFilterVar(
+        string $propertyName,
+        int $filter,
+        mixed $options = null,
+    ): ChainedValidator;
+
+    public static function propertyFinite(string $propertyName): ChainedValidator;
+
+    public static function propertyFloatType(string $propertyName): ChainedValidator;
+
+    public static function propertyFloatVal(string $propertyName): ChainedValidator;
+
+    public static function propertyGraph(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyGreaterThan(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyGreaterThanOrEqual(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyHetu(string $propertyName): ChainedValidator;
+
+    public static function propertyHexRgbColor(string $propertyName): ChainedValidator;
+
+    public static function propertyIban(string $propertyName): ChainedValidator;
+
+    public static function propertyIdentical(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyImage(string $propertyName): ChainedValidator;
+
+    public static function propertyImei(string $propertyName): ChainedValidator;
+
+    public static function propertyIn(
+        string $propertyName,
+        mixed $haystack,
+        bool $compareIdentical = false,
+    ): ChainedValidator;
+
+    public static function propertyInfinite(string $propertyName): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public static function propertyInstance(string $propertyName, string $class): ChainedValidator;
+
+    public static function propertyIntType(string $propertyName): ChainedValidator;
+
+    public static function propertyIntVal(string $propertyName): ChainedValidator;
+
+    public static function propertyIp(
+        string $propertyName,
+        string $range = '*',
+        ?int $options = null,
+    ): ChainedValidator;
+
+    public static function propertyIsbn(string $propertyName): ChainedValidator;
+
+    public static function propertyIterableType(string $propertyName): ChainedValidator;
+
+    public static function propertyIterableVal(string $propertyName): ChainedValidator;
+
+    public static function propertyJson(string $propertyName): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public static function propertyLanguageCode(string $propertyName, string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function propertyLazy(string $propertyName, callable $ruleCreator): ChainedValidator;
+
+    public static function propertyLeapDate(string $propertyName, string $format): ChainedValidator;
+
+    public static function propertyLeapYear(string $propertyName): ChainedValidator;
+
+    public static function propertyLength(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyLessThan(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyLessThanOrEqual(string $propertyName, mixed $compareTo): ChainedValidator;
+
+    public static function propertyLowercase(string $propertyName): ChainedValidator;
+
+    public static function propertyLuhn(string $propertyName): ChainedValidator;
+
+    public static function propertyMacAddress(string $propertyName): ChainedValidator;
+
+    public static function propertyMax(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyMaxAge(string $propertyName, int $age, ?string $format = null): ChainedValidator;
+
+    public static function propertyMimetype(string $propertyName, string $mimetype): ChainedValidator;
+
+    public static function propertyMin(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyMinAge(string $propertyName, int $age, ?string $format = null): ChainedValidator;
+
+    public static function propertyMultiple(string $propertyName, int $multipleOf): ChainedValidator;
+
+    public static function propertyNegative(string $propertyName): ChainedValidator;
+
+    public static function propertyNfeAccessKey(string $propertyName): ChainedValidator;
+
+    public static function propertyNif(string $propertyName): ChainedValidator;
+
+    public static function propertyNip(string $propertyName): ChainedValidator;
+
+    public static function propertyNo(string $propertyName, bool $useLocale = false): ChainedValidator;
+
+    public static function propertyNoWhitespace(string $propertyName): ChainedValidator;
+
+    public static function propertyNoneOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function propertyNot(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyNotBlank(string $propertyName): ChainedValidator;
+
+    public static function propertyNotEmoji(string $propertyName): ChainedValidator;
+
+    public static function propertyNotEmpty(string $propertyName): ChainedValidator;
+
+    public static function propertyNotOptional(string $propertyName): ChainedValidator;
+
+    public static function propertyNullType(string $propertyName): ChainedValidator;
+
+    public static function propertyNullable(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyNumber(string $propertyName): ChainedValidator;
+
+    public static function propertyNumericVal(string $propertyName): ChainedValidator;
+
+    public static function propertyObjectType(string $propertyName): ChainedValidator;
+
+    public static function propertyOdd(string $propertyName): ChainedValidator;
+
+    public static function propertyOneOf(
+        string $propertyName,
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function propertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyPerfectSquare(string $propertyName): ChainedValidator;
+
+    public static function propertyPesel(string $propertyName): ChainedValidator;
+
+    public static function propertyPhone(string $propertyName, ?string $countryCode = null): ChainedValidator;
+
+    public static function propertyPhpLabel(string $propertyName): ChainedValidator;
+
+    public static function propertyPis(string $propertyName): ChainedValidator;
+
+    public static function propertyPolishIdCard(string $propertyName): ChainedValidator;
+
+    public static function propertyPortugueseNif(string $propertyName): ChainedValidator;
+
+    public static function propertyPositive(string $propertyName): ChainedValidator;
+
+    public static function propertyPostalCode(
+        string $propertyName,
+        string $countryCode,
+        bool $formatted = false,
+    ): ChainedValidator;
+
+    public static function propertyPrimeNumber(string $propertyName): ChainedValidator;
+
+    public static function propertyPrintable(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyPublicDomainSuffix(string $propertyName): ChainedValidator;
+
+    public static function propertyPunct(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyReadable(string $propertyName): ChainedValidator;
+
+    public static function propertyRegex(string $propertyName, string $regex): ChainedValidator;
+
+    public static function propertyResourceType(string $propertyName): ChainedValidator;
+
+    public static function propertyRoman(string $propertyName): ChainedValidator;
+
+    public static function propertyScalarVal(string $propertyName): ChainedValidator;
+
+    public static function propertySize(
+        string $propertyName,
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public static function propertySlug(string $propertyName): ChainedValidator;
+
+    public static function propertySorted(string $propertyName, string $direction): ChainedValidator;
+
+    public static function propertySpace(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyStartsWith(
+        string $propertyName,
+        mixed $startValue,
+        bool $identical = false,
+    ): ChainedValidator;
+
+    public static function propertyStringType(string $propertyName): ChainedValidator;
+
+    public static function propertyStringVal(string $propertyName): ChainedValidator;
+
+    public static function propertySubdivisionCode(string $propertyName, string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public static function propertySubset(string $propertyName, array $superset): ChainedValidator;
+
+    public static function propertySymbolicLink(string $propertyName): ChainedValidator;
+
+    public static function propertyTime(string $propertyName, string $format = 'H:i:s'): ChainedValidator;
+
+    public static function propertyTld(string $propertyName): ChainedValidator;
+
+    public static function propertyTrueVal(string $propertyName): ChainedValidator;
+
+    public static function propertyUnique(string $propertyName): ChainedValidator;
+
+    public static function propertyUploaded(string $propertyName): ChainedValidator;
+
+    public static function propertyUppercase(string $propertyName): ChainedValidator;
+
+    public static function propertyUrl(string $propertyName): ChainedValidator;
+
+    public static function propertyUuid(string $propertyName, ?int $version = null): ChainedValidator;
+
+    public static function propertyVersion(string $propertyName): ChainedValidator;
+
+    public static function propertyVideoUrl(string $propertyName, ?string $service = null): ChainedValidator;
+
+    public static function propertyVowel(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyWhen(
+        string $propertyName,
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public static function propertyWritable(string $propertyName): ChainedValidator;
+
+    public static function propertyXdigit(string $propertyName, string ...$additionalChars): ChainedValidator;
+
+    public static function propertyYes(string $propertyName, bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/StaticUndefOr.php b/library/Mixins/StaticUndefOr.php
new file mode 100644
index 00000000..49b18e19
--- /dev/null
+++ b/library/Mixins/StaticUndefOr.php
@@ -0,0 +1,380 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Mixins;
+
+use Respect\Validation\Validatable;
+
+interface StaticUndefOr
+{
+    public static function undefOfAllOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function undefOfAlnum(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfAlpha(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfAlwaysInvalid(): ChainedValidator;
+
+    public static function undefOfAlwaysValid(): ChainedValidator;
+
+    public static function undefOfAnyOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function undefOfArrayType(): ChainedValidator;
+
+    public static function undefOfArrayVal(): ChainedValidator;
+
+    public static function undefOfBase(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
+
+    public static function undefOfBase64(): ChainedValidator;
+
+    public static function undefOfBetween(mixed $minValue, mixed $maxValue): ChainedValidator;
+
+    public static function undefOfBetweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
+
+    public static function undefOfBoolType(): ChainedValidator;
+
+    public static function undefOfBoolVal(): ChainedValidator;
+
+    public static function undefOfBsn(): ChainedValidator;
+
+    public static function undefOfCall(callable $callable, Validatable $rule): ChainedValidator;
+
+    public static function undefOfCallableType(): ChainedValidator;
+
+    public static function undefOfCallback(callable $callback, mixed ...$arguments): ChainedValidator;
+
+    public static function undefOfCharset(string $charset, string ...$charsets): ChainedValidator;
+
+    public static function undefOfCnh(): ChainedValidator;
+
+    public static function undefOfCnpj(): ChainedValidator;
+
+    public static function undefOfConsecutive(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function undefOfConsonant(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfContains(mixed $containsValue, bool $identical = false): ChainedValidator;
+
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function undefOfContainsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public static function undefOfControl(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfCountable(): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
+    public static function undefOfCountryCode(string $set = 'alpha-2'): ChainedValidator;
+
+    public static function undefOfCpf(): ChainedValidator;
+
+    public static function undefOfCreditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function undefOfCurrencyCode(string $set = 'alpha-3'): ChainedValidator;
+
+    public static function undefOfDate(string $format = 'Y-m-d'): ChainedValidator;
+
+    public static function undefOfDateTime(?string $format = null): ChainedValidator;
+
+    public static function undefOfDecimal(int $decimals): ChainedValidator;
+
+    public static function undefOfDigit(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfDirectory(): ChainedValidator;
+
+    public static function undefOfDomain(bool $tldCheck = true): ChainedValidator;
+
+    public static function undefOfEach(Validatable $rule): ChainedValidator;
+
+    public static function undefOfEmail(): ChainedValidator;
+
+    public static function undefOfEndsWith(mixed $endValue, bool $identical = false): ChainedValidator;
+
+    public static function undefOfEquals(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfEquivalent(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfEven(): ChainedValidator;
+
+    public static function undefOfExecutable(): ChainedValidator;
+
+    public static function undefOfExists(): ChainedValidator;
+
+    public static function undefOfExtension(string $extension): ChainedValidator;
+
+    public static function undefOfFactor(int $dividend): ChainedValidator;
+
+    public static function undefOfFalseVal(): ChainedValidator;
+
+    public static function undefOfFibonacci(): ChainedValidator;
+
+    public static function undefOfFile(): ChainedValidator;
+
+    public static function undefOfFilterVar(int $filter, mixed $options = null): ChainedValidator;
+
+    public static function undefOfFinite(): ChainedValidator;
+
+    public static function undefOfFloatType(): ChainedValidator;
+
+    public static function undefOfFloatVal(): ChainedValidator;
+
+    public static function undefOfGraph(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfGreaterThan(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfGreaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfHetu(): ChainedValidator;
+
+    public static function undefOfHexRgbColor(): ChainedValidator;
+
+    public static function undefOfIban(): ChainedValidator;
+
+    public static function undefOfIdentical(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfImage(): ChainedValidator;
+
+    public static function undefOfImei(): ChainedValidator;
+
+    public static function undefOfIn(mixed $haystack, bool $compareIdentical = false): ChainedValidator;
+
+    public static function undefOfInfinite(): ChainedValidator;
+
+    /**
+     * @param class-string $class
+     */
+    public static function undefOfInstance(string $class): ChainedValidator;
+
+    public static function undefOfIntType(): ChainedValidator;
+
+    public static function undefOfIntVal(): ChainedValidator;
+
+    public static function undefOfIp(string $range = '*', ?int $options = null): ChainedValidator;
+
+    public static function undefOfIsbn(): ChainedValidator;
+
+    public static function undefOfIterableType(): ChainedValidator;
+
+    public static function undefOfIterableVal(): ChainedValidator;
+
+    public static function undefOfJson(): ChainedValidator;
+
+    public static function undefOfKey(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function undefOfKeyExists(string|int $key): ChainedValidator;
+
+    public static function undefOfKeyOptional(string|int $key, Validatable $rule): ChainedValidator;
+
+    public static function undefOfKeySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
+
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
+    public static function undefOfLanguageCode(string $set = 'alpha-2'): ChainedValidator;
+
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function undefOfLazy(callable $ruleCreator): ChainedValidator;
+
+    public static function undefOfLeapDate(string $format): ChainedValidator;
+
+    public static function undefOfLeapYear(): ChainedValidator;
+
+    public static function undefOfLength(Validatable $rule): ChainedValidator;
+
+    public static function undefOfLessThan(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfLessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function undefOfLowercase(): ChainedValidator;
+
+    public static function undefOfLuhn(): ChainedValidator;
+
+    public static function undefOfMacAddress(): ChainedValidator;
+
+    public static function undefOfMax(Validatable $rule): ChainedValidator;
+
+    public static function undefOfMaxAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function undefOfMimetype(string $mimetype): ChainedValidator;
+
+    public static function undefOfMin(Validatable $rule): ChainedValidator;
+
+    public static function undefOfMinAge(int $age, ?string $format = null): ChainedValidator;
+
+    public static function undefOfMultiple(int $multipleOf): ChainedValidator;
+
+    public static function undefOfNegative(): ChainedValidator;
+
+    public static function undefOfNfeAccessKey(): ChainedValidator;
+
+    public static function undefOfNif(): ChainedValidator;
+
+    public static function undefOfNip(): ChainedValidator;
+
+    public static function undefOfNo(bool $useLocale = false): ChainedValidator;
+
+    public static function undefOfNoWhitespace(): ChainedValidator;
+
+    public static function undefOfNoneOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function undefOfNot(Validatable $rule): ChainedValidator;
+
+    public static function undefOfNotBlank(): ChainedValidator;
+
+    public static function undefOfNotEmoji(): ChainedValidator;
+
+    public static function undefOfNotEmpty(): ChainedValidator;
+
+    public static function undefOfNotOptional(): ChainedValidator;
+
+    public static function undefOfNullType(): ChainedValidator;
+
+    public static function undefOfNumber(): ChainedValidator;
+
+    public static function undefOfNumericVal(): ChainedValidator;
+
+    public static function undefOfObjectType(): ChainedValidator;
+
+    public static function undefOfOdd(): ChainedValidator;
+
+    public static function undefOfOneOf(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
+
+    public static function undefOfPerfectSquare(): ChainedValidator;
+
+    public static function undefOfPesel(): ChainedValidator;
+
+    public static function undefOfPhone(?string $countryCode = null): ChainedValidator;
+
+    public static function undefOfPhpLabel(): ChainedValidator;
+
+    public static function undefOfPis(): ChainedValidator;
+
+    public static function undefOfPolishIdCard(): ChainedValidator;
+
+    public static function undefOfPortugueseNif(): ChainedValidator;
+
+    public static function undefOfPositive(): ChainedValidator;
+
+    public static function undefOfPostalCode(string $countryCode, bool $formatted = false): ChainedValidator;
+
+    public static function undefOfPrimeNumber(): ChainedValidator;
+
+    public static function undefOfPrintable(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfProperty(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function undefOfPropertyExists(string $propertyName): ChainedValidator;
+
+    public static function undefOfPropertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function undefOfPublicDomainSuffix(): ChainedValidator;
+
+    public static function undefOfPunct(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfReadable(): ChainedValidator;
+
+    public static function undefOfRegex(string $regex): ChainedValidator;
+
+    public static function undefOfResourceType(): ChainedValidator;
+
+    public static function undefOfRoman(): ChainedValidator;
+
+    public static function undefOfScalarVal(): ChainedValidator;
+
+    public static function undefOfSize(
+        string|int|null $minSize = null,
+        string|int|null $maxSize = null,
+    ): ChainedValidator;
+
+    public static function undefOfSlug(): ChainedValidator;
+
+    public static function undefOfSorted(string $direction): ChainedValidator;
+
+    public static function undefOfSpace(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfStartsWith(mixed $startValue, bool $identical = false): ChainedValidator;
+
+    public static function undefOfStringType(): ChainedValidator;
+
+    public static function undefOfStringVal(): ChainedValidator;
+
+    public static function undefOfSubdivisionCode(string $countryCode): ChainedValidator;
+
+    /**
+     * @param mixed[] $superset
+     */
+    public static function undefOfSubset(array $superset): ChainedValidator;
+
+    public static function undefOfSymbolicLink(): ChainedValidator;
+
+    public static function undefOfTime(string $format = 'H:i:s'): ChainedValidator;
+
+    public static function undefOfTld(): ChainedValidator;
+
+    public static function undefOfTrueVal(): ChainedValidator;
+
+    public static function undefOfUnique(): ChainedValidator;
+
+    public static function undefOfUploaded(): ChainedValidator;
+
+    public static function undefOfUppercase(): ChainedValidator;
+
+    public static function undefOfUrl(): ChainedValidator;
+
+    public static function undefOfUuid(?int $version = null): ChainedValidator;
+
+    public static function undefOfVersion(): ChainedValidator;
+
+    public static function undefOfVideoUrl(?string $service = null): ChainedValidator;
+
+    public static function undefOfVowel(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfWhen(
+        Validatable $when,
+        Validatable $then,
+        ?Validatable $else = null,
+    ): ChainedValidator;
+
+    public static function undefOfWritable(): ChainedValidator;
+
+    public static function undefOfXdigit(string ...$additionalChars): ChainedValidator;
+
+    public static function undefOfYes(bool $useLocale = false): ChainedValidator;
+}
diff --git a/library/Mixins/StaticValidator.php b/library/Mixins/StaticValidator.php
index c09530a7..0c083646 100644
--- a/library/Mixins/StaticValidator.php
+++ b/library/Mixins/StaticValidator.php
@@ -9,12 +9,19 @@ declare(strict_types=1);
 
 namespace Respect\Validation\Mixins;
 
-use finfo;
 use Respect\Validation\Validatable;
 
-interface StaticValidator
+interface StaticValidator extends
+    StaticKey,
+    StaticLength,
+    StaticMax,
+    StaticMin,
+    StaticNot,
+    StaticNullOr,
+    StaticProperty,
+    StaticUndefOr
 {
-    public static function allOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public static function allOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public static function alnum(string ...$additionalChars): ChainedValidator;
 
@@ -24,28 +31,23 @@ interface StaticValidator
 
     public static function alwaysValid(): ChainedValidator;
 
-    public static function anyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public static function anyOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public static function arrayType(): ChainedValidator;
 
     public static function arrayVal(): ChainedValidator;
 
-    public static function property(string $propertyName, Validatable $validator): ChainedValidator;
-
-    public static function propertyExists(string $propertyName): ChainedValidator;
-
-    public static function propertyOptional(string $propertyName, Validatable $validator): ChainedValidator;
-
-    public static function base(int $base, ?string $chars = null): ChainedValidator;
+    public static function base(
+        int $base,
+        string $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    ): ChainedValidator;
 
     public static function base64(): ChainedValidator;
 
-    public static function between(mixed $minimum, mixed $maximum): ChainedValidator;
+    public static function between(mixed $minValue, mixed $maxValue): ChainedValidator;
 
     public static function betweenExclusive(mixed $minimum, mixed $maximum): ChainedValidator;
 
-    public static function bic(string $countryCode): ChainedValidator;
-
     public static function boolType(): ChainedValidator;
 
     public static function boolVal(): ChainedValidator;
@@ -56,7 +58,7 @@ interface StaticValidator
 
     public static function callableType(): ChainedValidator;
 
-    public static function callback(callable $callback): ChainedValidator;
+    public static function callback(callable $callback, mixed ...$arguments): ChainedValidator;
 
     public static function charset(string $charset, string ...$charsets): ChainedValidator;
 
@@ -64,28 +66,38 @@ interface StaticValidator
 
     public static function cnpj(): ChainedValidator;
 
-    public static function consecutive(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
-
-    public static function control(string ...$additionalChars): ChainedValidator;
+    public static function consecutive(
+        Validatable $rule1,
+        Validatable $rule2,
+        Validatable ...$rules,
+    ): ChainedValidator;
 
     public static function consonant(string ...$additionalChars): ChainedValidator;
 
     public static function contains(mixed $containsValue, bool $identical = false): ChainedValidator;
 
-    /** @param non-empty-array<mixed> $needles */
-    public static function containsAny(array $needles, bool $strictCompareArray = false): ChainedValidator;
+    /**
+     * @param non-empty-array<mixed> $needles
+     */
+    public static function containsAny(array $needles, bool $identical = false): ChainedValidator;
+
+    public static function control(string ...$additionalChars): ChainedValidator;
 
     public static function countable(): ChainedValidator;
 
-    /** @param "alpha-2"|"alpha-3"|"numeric" $set */
+    /**
+     * @param "alpha-2"|"alpha-3"|"numeric" $set
+     */
     public static function countryCode(string $set = 'alpha-2'): ChainedValidator;
 
-    /** @param "alpha-3"|"numeric" $set */
-    public static function currencyCode(string $set = 'alpha-3'): ChainedValidator;
-
     public static function cpf(): ChainedValidator;
 
-    public static function creditCard(?string $brand = null): ChainedValidator;
+    public static function creditCard(string $brand = 'Any'): ChainedValidator;
+
+    /**
+     * @param "alpha-3"|"numeric" $set
+     */
+    public static function currencyCode(string $set = 'alpha-3'): ChainedValidator;
 
     public static function date(string $format = 'Y-m-d'): ChainedValidator;
 
@@ -125,21 +137,20 @@ interface StaticValidator
 
     public static function file(): ChainedValidator;
 
-    /**
-     * @param mixed[]|int $options
-     */
-    public static function filterVar(int $filter, array|int|null $options = null): ChainedValidator;
+    public static function filterVar(int $filter, mixed $options = null): ChainedValidator;
 
     public static function finite(): ChainedValidator;
 
-    public static function floatVal(): ChainedValidator;
-
     public static function floatType(): ChainedValidator;
 
+    public static function floatVal(): ChainedValidator;
+
     public static function graph(string ...$additionalChars): ChainedValidator;
 
     public static function greaterThan(mixed $compareTo): ChainedValidator;
 
+    public static function greaterThanOrEqual(mixed $compareTo): ChainedValidator;
+
     public static function hetu(): ChainedValidator;
 
     public static function hexRgbColor(): ChainedValidator;
@@ -148,7 +159,7 @@ interface StaticValidator
 
     public static function identical(mixed $compareTo): ChainedValidator;
 
-    public static function image(?finfo $fileInfo = null): ChainedValidator;
+    public static function image(): ChainedValidator;
 
     public static function imei(): ChainedValidator;
 
@@ -156,12 +167,15 @@ interface StaticValidator
 
     public static function infinite(): ChainedValidator;
 
-    public static function instance(string $instanceName): ChainedValidator;
-
-    public static function intVal(): ChainedValidator;
+    /**
+     * @param class-string $class
+     */
+    public static function instance(string $class): ChainedValidator;
 
     public static function intType(): ChainedValidator;
 
+    public static function intVal(): ChainedValidator;
+
     public static function ip(string $range = '*', ?int $options = null): ChainedValidator;
 
     public static function isbn(): ChainedValidator;
@@ -172,45 +186,47 @@ interface StaticValidator
 
     public static function json(): ChainedValidator;
 
-    public static function key(int|string $key, Validatable $rule): ChainedValidator;
+    public static function key(string|int $key, Validatable $rule): ChainedValidator;
 
-    public static function keyExists(int|string $key): ChainedValidator;
+    public static function keyExists(string|int $key): ChainedValidator;
 
-    public static function keyOptional(int|string $key, Validatable $rule): ChainedValidator;
+    public static function keyOptional(string|int $key, Validatable $rule): ChainedValidator;
 
     public static function keySet(Validatable $rule, Validatable ...$rules): ChainedValidator;
 
-    /** @param callable(mixed): Validatable $ruleCreator */
-    public static function lazy(callable $ruleCreator): ChainedValidator;
-
-    /** @param "alpha-2"|"alpha-3" $set */
+    /**
+     * @param "alpha-2"|"alpha-3" $set
+     */
     public static function languageCode(string $set = 'alpha-2'): ChainedValidator;
 
+    /**
+     * @param callable(mixed): Validatable $ruleCreator
+     */
+    public static function lazy(callable $ruleCreator): ChainedValidator;
+
     public static function leapDate(string $format): ChainedValidator;
 
     public static function leapYear(): ChainedValidator;
 
     public static function length(Validatable $rule): ChainedValidator;
 
-    public static function lowercase(): ChainedValidator;
-
     public static function lessThan(mixed $compareTo): ChainedValidator;
 
+    public static function lessThanOrEqual(mixed $compareTo): ChainedValidator;
+
+    public static function lowercase(): ChainedValidator;
+
     public static function luhn(): ChainedValidator;
 
     public static function macAddress(): ChainedValidator;
 
-    public static function lessThanOrEqual(mixed $compareTo): ChainedValidator;
-
     public static function max(Validatable $rule): ChainedValidator;
 
     public static function maxAge(int $age, ?string $format = null): ChainedValidator;
 
-    public static function min(Validatable $rule): ChainedValidator;
-
     public static function mimetype(string $mimetype): ChainedValidator;
 
-    public static function greaterThanOrEqual(mixed $compareTo): ChainedValidator;
+    public static function min(Validatable $rule): ChainedValidator;
 
     public static function minAge(int $age, ?string $format = null): ChainedValidator;
 
@@ -226,7 +242,9 @@ interface StaticValidator
 
     public static function no(bool $useLocale = false): ChainedValidator;
 
-    public static function noneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public static function noWhitespace(): ChainedValidator;
+
+    public static function noneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public static function not(Validatable $rule): ChainedValidator;
 
@@ -238,12 +256,10 @@ interface StaticValidator
 
     public static function notOptional(): ChainedValidator;
 
-    public static function noWhitespace(): ChainedValidator;
+    public static function nullType(): ChainedValidator;
 
     public static function nullable(Validatable $rule): ChainedValidator;
 
-    public static function nullType(): ChainedValidator;
-
     public static function number(): ChainedValidator;
 
     public static function numericVal(): ChainedValidator;
@@ -252,7 +268,7 @@ interface StaticValidator
 
     public static function odd(): ChainedValidator;
 
-    public static function oneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rule): ChainedValidator;
+    public static function oneOf(Validatable $rule1, Validatable $rule2, Validatable ...$rules): ChainedValidator;
 
     public static function optional(Validatable $rule): ChainedValidator;
 
@@ -268,14 +284,24 @@ interface StaticValidator
 
     public static function polishIdCard(): ChainedValidator;
 
+    public static function portugueseNif(): ChainedValidator;
+
     public static function positive(): ChainedValidator;
 
-    public static function postalCode(string $countryCode): ChainedValidator;
+    public static function postalCode(string $countryCode, bool $formatted = false): ChainedValidator;
 
     public static function primeNumber(): ChainedValidator;
 
     public static function printable(string ...$additionalChars): ChainedValidator;
 
+    public static function property(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function propertyExists(string $propertyName): ChainedValidator;
+
+    public static function propertyOptional(string $propertyName, Validatable $rule): ChainedValidator;
+
+    public static function publicDomainSuffix(): ChainedValidator;
+
     public static function punct(string ...$additionalChars): ChainedValidator;
 
     public static function readable(): ChainedValidator;
@@ -288,7 +314,7 @@ interface StaticValidator
 
     public static function scalarVal(): ChainedValidator;
 
-    public static function size(?string $minSize = null, ?string $maxSize = null): ChainedValidator;
+    public static function size(string|int|null $minSize = null, string|int|null $maxSize = null): ChainedValidator;
 
     public static function slug(): ChainedValidator;
 
@@ -317,8 +343,6 @@ interface StaticValidator
 
     public static function trueVal(): ChainedValidator;
 
-    public static function type(string $type): ChainedValidator;
-
     public static function unique(): ChainedValidator;
 
     public static function uploaded(): ChainedValidator;
@@ -335,7 +359,7 @@ interface StaticValidator
 
     public static function vowel(string ...$additionalChars): ChainedValidator;
 
-    public static function when(Validatable $if, Validatable $then, ?Validatable $else = null): ChainedValidator;
+    public static function when(Validatable $when, Validatable $then, ?Validatable $else = null): ChainedValidator;
 
     public static function writable(): ChainedValidator;
 
diff --git a/library/Rules/ContainsAny.php b/library/Rules/ContainsAny.php
index ea592ba6..1375370a 100644
--- a/library/Rules/ContainsAny.php
+++ b/library/Rules/ContainsAny.php
@@ -22,10 +22,7 @@ use function count;
 )]
 final class ContainsAny extends Envelope
 {
-    /**
-     * @param non-empty-array<mixed> $needles At least one of the values provided must be found in input string or array
-     * @param bool $identical Defines whether the value should be compared strictly, when validating array
-     */
+    /** @param non-empty-array<mixed> $needles */
     public function __construct(array $needles, bool $identical = false)
     {
         // @phpstan-ignore-next-line
diff --git a/library/Rules/Lazy.php b/library/Rules/Lazy.php
index a0d8294d..de6fcf5e 100644
--- a/library/Rules/Lazy.php
+++ b/library/Rules/Lazy.php
@@ -24,9 +24,7 @@ final class Lazy extends Standard
     /** @var callable(mixed): Validatable */
     private $ruleCreator;
 
-    /**
-     * @param callable(mixed): Validatable $ruleCreator
-     */
+    /** @param callable(mixed): Validatable $ruleCreator */
     public function __construct(callable $ruleCreator)
     {
         $this->ruleCreator = $ruleCreator;
diff --git a/library/Rules/Subset.php b/library/Rules/Subset.php
index bf768429..801c4d77 100644
--- a/library/Rules/Subset.php
+++ b/library/Rules/Subset.php
@@ -22,9 +22,7 @@ use function is_array;
 )]
 final class Subset extends Standard
 {
-    /**
-     * @param mixed[] $superset
-     */
+    /** @param mixed[] $superset */
     public function __construct(
         private readonly array $superset
     ) {
diff --git a/library/Transformers/DeprecatedLength.php b/library/Transformers/DeprecatedLength.php
index 13c05c32..d8b07ab7 100644
--- a/library/Transformers/DeprecatedLength.php
+++ b/library/Transformers/DeprecatedLength.php
@@ -9,13 +9,6 @@ declare(strict_types=1);
 
 namespace Respect\Validation\Transformers;
 
-use Respect\Validation\Rules\Between;
-use Respect\Validation\Rules\BetweenExclusive;
-use Respect\Validation\Rules\Equals;
-use Respect\Validation\Rules\GreaterThan;
-use Respect\Validation\Rules\GreaterThanOrEqual;
-use Respect\Validation\Rules\LessThan;
-use Respect\Validation\Rules\LessThanOrEqual;
 use Respect\Validation\Validatable;
 
 use function Respect\Stringifier\stringify;
@@ -49,59 +42,40 @@ final class DeprecatedLength implements Transformer
             'and will not be allowed in the next major version. ';
 
         if (!$minValue) {
+            $name = $inclusive ? 'LessThanOrEqual' : 'LessThan';
             trigger_error(
-                sprintf(
-                    $message . 'Use length(%s(%s)) instead.',
-                    $inclusive ? 'lessThanOrEqual' : 'lessThan',
-                    stringify($maxValue),
-                ),
+                sprintf($message . 'Use length%s(%s) instead.', $name, stringify($maxValue)),
                 E_USER_DEPRECATED
             );
 
-            return new RuleSpec(
-                'length',
-                [$inclusive ? new LessThanOrEqual($maxValue) : new LessThan($maxValue)]
-            );
+            return new RuleSpec($name, [$maxValue], new RuleSpec('length'));
         }
 
         if (!$maxValue) {
+            $name = $inclusive ? 'GreaterThanOrEqual' : 'GreaterThan';
             trigger_error(
-                sprintf(
-                    $message . 'Use length(%s(%s)) instead.',
-                    $inclusive ? 'greaterThanOrEqual' : 'greaterThan',
-                    stringify($minValue),
-                ),
+                sprintf($message . 'Use length%s(%s) instead.', $name, stringify($minValue)),
                 E_USER_DEPRECATED
             );
 
-            return new RuleSpec(
-                'length',
-                [$inclusive ? new GreaterThanOrEqual($minValue) : new GreaterThan($minValue)]
-            );
+            return new RuleSpec($name, [$minValue], new RuleSpec('length'));
         }
 
         if ($minValue === $maxValue) {
             trigger_error(
-                sprintf($message . 'Use length(equals(%s)) instead.', stringify($minValue)),
+                sprintf($message . 'Use lengthEquals(%s) instead.', stringify($minValue)),
                 E_USER_DEPRECATED
             );
 
-            return new RuleSpec('length', [new Equals($minValue)]);
+            return new RuleSpec('equals', [$minValue], new RuleSpec('length'));
         }
 
+        $name = $inclusive ? 'Between' : 'BetweenExclusive';
         trigger_error(
-            sprintf(
-                $message . 'Use length(%s(%s, %s)) instead.',
-                $inclusive ? 'between' : 'betweenExclusive',
-                stringify($minValue),
-                stringify($maxValue),
-            ),
+            sprintf($message . 'Use length%s(%s, %s) instead.', $name, stringify($minValue), stringify($maxValue)),
             E_USER_DEPRECATED
         );
 
-        return new RuleSpec(
-            'length',
-            [$inclusive ? new Between($minValue, $maxValue) : new BetweenExclusive($minValue, $maxValue)]
-        );
+        return new RuleSpec($name, [$minValue, $maxValue], new RuleSpec('length'));
     }
 }
diff --git a/library/Transformers/DeprecatedType.php b/library/Transformers/DeprecatedType.php
index af153db2..ddbcae6c 100644
--- a/library/Transformers/DeprecatedType.php
+++ b/library/Transformers/DeprecatedType.php
@@ -32,10 +32,15 @@ final class DeprecatedType implements Transformer
         'string' => 'stringType',
     ];
 
+    public function __construct(
+        private readonly Transformer $next
+    ) {
+    }
+
     public function transform(RuleSpec $ruleSpec): RuleSpec
     {
         if ($ruleSpec->name !== 'type') {
-            return $ruleSpec;
+            return $this->next->transform($ruleSpec);
         }
 
         $type = current($ruleSpec->arguments);
diff --git a/library/Transformers/Prefix.php b/library/Transformers/Prefix.php
new file mode 100644
index 00000000..4b1bbf42
--- /dev/null
+++ b/library/Transformers/Prefix.php
@@ -0,0 +1,87 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Transformers;
+
+use function array_shift;
+use function in_array;
+use function str_starts_with;
+use function substr;
+
+final class Prefix implements Transformer
+{
+    private const RULES_TO_SKIP = [
+        'key',
+        'keyExists',
+        'keyOptional',
+        'keySet',
+        'length',
+        'max',
+        'maxAge',
+        'min',
+        'minAge',
+        'not',
+        'notBlank',
+        'notEmoji',
+        'notEmpty',
+        'notOptional',
+        'property',
+        'propertyExists',
+        'propertyOptional',
+    ];
+
+    public function transform(RuleSpec $ruleSpec): RuleSpec
+    {
+        if ($ruleSpec->wrapper !== null || in_array($ruleSpec->name, self::RULES_TO_SKIP, true)) {
+            return $ruleSpec;
+        }
+
+        if (str_starts_with($ruleSpec->name, 'key')) {
+            $arguments = $ruleSpec->arguments;
+            array_shift($arguments);
+            $wrapperArguments = [$ruleSpec->arguments[0]];
+
+            return new RuleSpec(substr($ruleSpec->name, 3), $arguments, new RuleSpec('key', $wrapperArguments));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'length')) {
+            return new RuleSpec(substr($ruleSpec->name, 6), $ruleSpec->arguments, new RuleSpec('length'));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'max')) {
+            return new RuleSpec(substr($ruleSpec->name, 3), $ruleSpec->arguments, new RuleSpec('max'));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'min')) {
+            return new RuleSpec(substr($ruleSpec->name, 3), $ruleSpec->arguments, new RuleSpec('min'));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'not')) {
+            return new RuleSpec(substr($ruleSpec->name, 3), $ruleSpec->arguments, new RuleSpec('not'));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'nullOr')) {
+            return new RuleSpec(substr($ruleSpec->name, 6), $ruleSpec->arguments, new RuleSpec('nullable'));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'property')) {
+            $arguments = $ruleSpec->arguments;
+            array_shift($arguments);
+            $wrapperArguments = [$ruleSpec->arguments[0]];
+
+            return new RuleSpec(substr($ruleSpec->name, 8), $arguments, new RuleSpec('property', $wrapperArguments));
+        }
+
+        if (str_starts_with($ruleSpec->name, 'undefOr')) {
+            return new RuleSpec(substr($ruleSpec->name, 7), $ruleSpec->arguments, new RuleSpec('optional'));
+        }
+
+        return $ruleSpec;
+    }
+}
diff --git a/library/Transformers/RuleSpec.php b/library/Transformers/RuleSpec.php
index 41ff9555..94ba06e5 100644
--- a/library/Transformers/RuleSpec.php
+++ b/library/Transformers/RuleSpec.php
@@ -14,7 +14,8 @@ final class RuleSpec
     /** @param array<mixed> $arguments */
     public function __construct(
         public readonly string $name,
-        public readonly array $arguments = []
+        public readonly array $arguments = [],
+        public readonly ?RuleSpec $wrapper = null,
     ) {
     }
 }
diff --git a/library/Validator.php b/library/Validator.php
index 35a4f6cc..d7d3cc4d 100644
--- a/library/Validator.php
+++ b/library/Validator.php
@@ -14,7 +14,6 @@ use Respect\Validation\Helpers\CanBindEvaluateRule;
 use Respect\Validation\Message\Formatter;
 use Respect\Validation\Message\StandardFormatter;
 use Respect\Validation\Message\StandardRenderer;
-use Respect\Validation\Mixins\ChainedValidator;
 use Respect\Validation\Mixins\StaticValidator;
 use Respect\Validation\Rules\AbstractRule;
 use Respect\Validation\Rules\AllOf;
@@ -24,7 +23,6 @@ use function current;
 
 /**
  * @mixin StaticValidator
- * @mixin ChainedValidator
  */
 final class Validator extends AbstractRule
 {
diff --git a/tests/integration/do_not_rely_on_nested_validation_exception_interface_for_check.phpt b/tests/integration/do_not_rely_on_nested_validation_exception_interface_for_check.phpt
index bc81e136..3665218e 100644
--- a/tests/integration/do_not_rely_on_nested_validation_exception_interface_for_check.phpt
+++ b/tests/integration/do_not_rely_on_nested_validation_exception_interface_for_check.phpt
@@ -10,10 +10,7 @@ require 'vendor/autoload.php';
 use Respect\Validation\Validator;
 
 exceptionMessage(
-    static fn () => Validator::alnum('__')
-        ->length(Validator::between(1, 15))
-        ->noWhitespace()
-        ->check('really messed up screen#name')
+    static fn () => Validator::alnum('__')->lengthBetween(1, 15)->noWhitespace()->check('really messed up screen#name')
 );
 ?>
 --EXPECT--
diff --git a/tests/integration/get_full_message_should_include_all_validation_messages_in_a_chain.phpt b/tests/integration/get_full_message_should_include_all_validation_messages_in_a_chain.phpt
index ae62bf73..4b16e882 100644
--- a/tests/integration/get_full_message_should_include_all_validation_messages_in_a_chain.phpt
+++ b/tests/integration/get_full_message_should_include_all_validation_messages_in_a_chain.phpt
@@ -7,9 +7,7 @@ require 'vendor/autoload.php';
 
 use Respect\Validation\Validator;
 
-exceptionFullMessage(
-    static fn() => Validator::stringType()->length(Validator::between(2, 15))->assert(0)
-);
+exceptionFullMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->assert(0));
 ?>
 --EXPECT--
 - All of the required rules must pass for 0
diff --git a/tests/integration/get_messages_should_include_all_validation_messages_in_a_chain.phpt b/tests/integration/get_messages_should_include_all_validation_messages_in_a_chain.phpt
index d0401a33..c0c8ba64 100644
--- a/tests/integration/get_messages_should_include_all_validation_messages_in_a_chain.phpt
+++ b/tests/integration/get_messages_should_include_all_validation_messages_in_a_chain.phpt
@@ -17,7 +17,7 @@ exceptionMessages(static function (): void {
     ];
 
     Validator::create()
-        ->key('username', Validator::length(Validator::between(2, 32)))
+        ->key('username', Validator::lengthBetween(2, 32))
         ->key('birthdate', Validator::dateTime())
         ->key('password', Validator::notEmpty())
         ->key('email', Validator::email())
diff --git a/tests/integration/issue-1376.phpt b/tests/integration/issue-1376.phpt
index 11b03080..bbc4ea37 100644
--- a/tests/integration/issue-1376.phpt
+++ b/tests/integration/issue-1376.phpt
@@ -8,10 +8,10 @@ require 'vendor/autoload.php';
 use Respect\Validation\Validator as v;
 
 exceptionFullMessage(static function (): void {
-    v::property('title', v::length(v::between(2, 3))->stringType())
+    v::property('title', v::lengthBetween(2, 3)->stringType())
             ->property('description', v::stringType())
-            ->property('author', v::intType()->length(v::between(1, 2)))
-            ->property('user', v::intVal()->length(v::between(1, 2)))
+            ->property('author', v::intType()->lengthBetween(1, 2))
+            ->property('user', v::intVal()->lengthBetween(1, 2))
             ->assert((object) ['author' => 'foo']);
 });
 
diff --git a/tests/integration/issue-425.phpt b/tests/integration/issue-425.phpt
index c5e813a1..0eae4420 100644
--- a/tests/integration/issue-425.phpt
+++ b/tests/integration/issue-425.phpt
@@ -9,7 +9,7 @@ use Respect\Validation\Validator as v;
 
 $validator = v::create()
     ->key('age', v::intType()->notEmpty()->noneOf(v::stringType(), v::arrayType()))
-    ->key('reference', v::stringType()->notEmpty()->length(v::between(1, 50)));
+    ->key('reference', v::stringType()->notEmpty()->lengthBetween(1, 50));
 
 exceptionFullMessage(static fn() => $validator->assert(['age' => 1]));
 exceptionFullMessage(static fn() => $validator->assert(['reference' => 'QSF1234']));
diff --git a/tests/integration/issue-446.phpt b/tests/integration/issue-446.phpt
index d891aab1..9588349d 100644
--- a/tests/integration/issue-446.phpt
+++ b/tests/integration/issue-446.phpt
@@ -13,7 +13,10 @@ $arr = [
 ];
 
 exceptionMessages(static function () use ($arr): void {
-    v::create()->key('name', v::length(v::between(2, 32)))->key('email', v::email())->assert($arr);
+    v::create()
+        ->key('name', v::lengthBetween(2, 32))
+        ->key('email', v::email())
+        ->assert($arr);
 });
 ?>
 --EXPECT--
diff --git a/tests/integration/readme/example_2.phpt b/tests/integration/readme/example_2.phpt
index 703bb4a4..666d9072 100644
--- a/tests/integration/readme/example_2.phpt
+++ b/tests/integration/readme/example_2.phpt
@@ -8,7 +8,7 @@ require 'vendor/autoload.php';
 use Respect\Validation\Validator as v;
 
 exceptionFullMessage(
-    static fn() => v::alnum()->noWhitespace()->length(v::between(1, 15))->assert('really messed up screen#name')
+    static fn() => v::alnum()->noWhitespace()->lengthBetween(1, 15)->assert('really messed up screen#name')
 );
 ?>
 --EXPECT--
diff --git a/tests/integration/readme/getting_messages_as_an_array.phpt b/tests/integration/readme/getting_messages_as_an_array.phpt
index 706a4898..e3ea2096 100644
--- a/tests/integration/readme/getting_messages_as_an_array.phpt
+++ b/tests/integration/readme/getting_messages_as_an_array.phpt
@@ -8,7 +8,7 @@ require 'vendor/autoload.php';
 use Respect\Validation\Validator as v;
 
 exceptionMessages(
-    static fn() => v::alnum()->noWhitespace()->length(v::between(1, 15))->assert('really messed up screen#name')
+    static fn() => v::alnum()->noWhitespace()->lengthBetween(1, 15)->assert('really messed up screen#name')
 );
 ?>
 --EXPECT--
diff --git a/tests/integration/rules/deprecated/attribute.phpt b/tests/integration/transformers/deprecated_attribute.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/attribute.phpt
rename to tests/integration/transformers/deprecated_attribute.phpt
diff --git a/tests/integration/rules/deprecated/key.phpt b/tests/integration/transformers/deprecated_key.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/key.phpt
rename to tests/integration/transformers/deprecated_key.phpt
diff --git a/tests/integration/rules/deprecated/keyNested.phpt b/tests/integration/transformers/deprecated_keyNested.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/keyNested.phpt
rename to tests/integration/transformers/deprecated_keyNested.phpt
diff --git a/tests/integration/rules/deprecated/keyValue.phpt b/tests/integration/transformers/deprecated_keyValue.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/keyValue.phpt
rename to tests/integration/transformers/deprecated_keyValue.phpt
diff --git a/tests/integration/rules/deprecated/length.phpt b/tests/integration/transformers/deprecated_length.phpt
similarity index 88%
rename from tests/integration/rules/deprecated/length.phpt
rename to tests/integration/transformers/deprecated_length.phpt
index ba44b543..362b3d4a 100644
--- a/tests/integration/rules/deprecated/length.phpt
+++ b/tests/integration/transformers/deprecated_length.phpt
@@ -35,74 +35,74 @@ exceptionFullMessage(static fn() => v::not(v::length(5, 5))->assert('grove'));
 ?>
 --EXPECTF--
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThan(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThan(5) instead. in %s
 The length of "forest" must be less than 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(between(10, 20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetween(10, 20) instead. in %s
 The length of "river" must be between 10 and 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThan(15)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThan(15) instead. in %s
 The length of "mountain" must be greater than 15
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThanOrEqual(20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThanOrEqual(20) instead. in %s
 The length of "ocean" must be greater than or equal to 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(between(2, 5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetween(2, 5) instead. in %s
 The length of "desert" must be between 2 and 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThanOrEqual(15)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThanOrEqual(15) instead. in %s
 The length of "rainforest" must not be less than or equal to 15
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThan(20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThan(20) instead. in %s
 The length of "glacier" must not be less than 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThanOrEqual(3)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThanOrEqual(3) instead. in %s
 The length of "meadow" must not be greater than or equal to 3
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThan(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThan(5) instead. in %s
 The length of "volcano" must not be greater than 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(between(5, 20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetween(5, 20) instead. in %s
 The length of "canyon" must not be between 5 and 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThan(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThan(5) instead. in %s
 - The length of "prairie" must be less than 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThanOrEqual(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThanOrEqual(5) instead. in %s
 - The length of "wetland" must be less than or equal to 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThan(15)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThan(15) instead. in %s
 - The length of "tundra" must be greater than 15
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThanOrEqual(20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThanOrEqual(20) instead. in %s
 - The length of "savanna" must be greater than or equal to 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(between(7, 10)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetween(7, 10) instead. in %s
 - The length of "marsh" must be between 7 and 10
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(betweenExclusive(4, 10)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetweenExclusive(4, 10) instead. in %s
 - The length of "reef" must be greater than 4 and less than 10
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThanOrEqual(15)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThanOrEqual(15) instead. in %s
 - The length of "valley" must not be less than or equal to 15
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(lessThan(20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthLessThan(20) instead. in %s
 - The length of "island" must not be less than 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThanOrEqual(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThanOrEqual(5) instead. in %s
 - The length of "plateau" must not be greater than or equal to 5
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(greaterThan(3)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthGreaterThan(3) instead. in %s
 - The length of "fjord" must not be greater than 3
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(between(5, 20)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetween(5, 20) instead. in %s
 - The length of "delta" must not be between 5 and 20
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(betweenExclusive(5, 11)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthBetweenExclusive(5, 11) instead. in %s
 - The length of "waterfall" must not be greater than 5 and less than 11
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(equals(8)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthEquals(8) instead. in %s
 - The length of "estuary" must equal 8
 
-Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use length(equals(5)) instead. in %s
+Deprecated: Calling length() with scalar values has been deprecated, and will not be allowed in the next major version. Use lengthEquals(5) instead. in %s
 - The length of "grove" must not equal 5
diff --git a/tests/integration/rules/deprecated/max.phpt b/tests/integration/transformers/deprecated_max.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/max.phpt
rename to tests/integration/transformers/deprecated_max.phpt
diff --git a/tests/integration/rules/deprecated/min.phpt b/tests/integration/transformers/deprecated_min.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/min.phpt
rename to tests/integration/transformers/deprecated_min.phpt
diff --git a/tests/integration/rules/deprecated/type.phpt b/tests/integration/transformers/deprecated_type.phpt
similarity index 100%
rename from tests/integration/rules/deprecated/type.phpt
rename to tests/integration/transformers/deprecated_type.phpt
diff --git a/tests/integration/transformers/prefix.phpt b/tests/integration/transformers/prefix.phpt
new file mode 100644
index 00000000..d5213419
--- /dev/null
+++ b/tests/integration/transformers/prefix.phpt
@@ -0,0 +1,85 @@
+--FILE--
+<?php
+
+declare(strict_types=1);
+
+require 'vendor/autoload.php';
+
+use Respect\Validation\Validator as v;
+
+run([
+    'key' => [v::keyEquals('foo', 12), ['foo' => 10]],
+    'length' => [v::lengthGreaterThan(3), 'foo'],
+    'max' => [v::maxOdd(), [1, 2, 3, 4]],
+    'min' => [v::minEven(), [1, 2, 3]],
+    'not' => [v::notBetween(1, 3), 2],
+    'nullOr' => [v::nullOrBoolType(), 'string'],
+    'property' => [v::propertyBetween('foo', 1, 3), (object) ['foo' => 5]],
+    'undefOr' => [v::undefOrUrl(), 'string'],
+]);
+// phpcs:disable Generic.Files.LineLength.TooLong
+?>
+--EXPECT--
+key
+⎺⎺⎺
+foo must equal 12
+- foo must equal 12
+[
+    'foo' => 'foo must equal 12',
+]
+
+length
+⎺⎺⎺⎺⎺⎺
+The length of "foo" must be greater than 3
+- The length of "foo" must be greater than 3
+[
+    'length' => 'The length of "foo" must be greater than 3',
+]
+
+max
+⎺⎺⎺
+As the maximum of `[1, 2, 3, 4]`, 4 must be an odd number
+- As the maximum of `[1, 2, 3, 4]`, 4 must be an odd number
+[
+    'max' => 'As the maximum of `[1, 2, 3, 4]`, 4 must be an odd number',
+]
+
+min
+⎺⎺⎺
+As the minimum from `[1, 2, 3]`, 1 must be an even number
+- As the minimum from `[1, 2, 3]`, 1 must be an even number
+[
+    'min' => 'As the minimum from `[1, 2, 3]`, 1 must be an even number',
+]
+
+not
+⎺⎺⎺
+2 must not be between 1 and 3
+- 2 must not be between 1 and 3
+[
+    'between' => '2 must not be between 1 and 3',
+]
+
+nullOr
+⎺⎺⎺⎺⎺⎺
+"string" must be of type boolean
+- "string" must be of type boolean
+[
+    'boolType' => '"string" must be of type boolean',
+]
+
+property
+⎺⎺⎺⎺⎺⎺⎺⎺
+foo must be between 1 and 3
+- foo must be between 1 and 3
+[
+    'foo' => 'foo must be between 1 and 3',
+]
+
+undefOr
+⎺⎺⎺⎺⎺⎺⎺
+"string" must be a URL
+- "string" must be a URL
+[
+    'url' => '"string" must be a URL',
+]
diff --git a/tests/integration/translator-assert.phpt b/tests/integration/translator-assert.phpt
index 4ab84b14..1e58737a 100644
--- a/tests/integration/translator-assert.phpt
+++ b/tests/integration/translator-assert.phpt
@@ -29,7 +29,7 @@ Factory::setDefaultInstance(
         })
 );
 
-exceptionFullMessage(static fn() => Validator::stringType()->length(Validator::between(2, 15))->phone('US')->assert(0));
+exceptionFullMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->phone('US')->assert(0));
 ?>
 --EXPECT--
 - Todas as regras requeridas devem passar para 0
diff --git a/tests/integration/translator-check.phpt b/tests/integration/translator-check.phpt
index 39834da5..e2cca125 100644
--- a/tests/integration/translator-check.phpt
+++ b/tests/integration/translator-check.phpt
@@ -17,7 +17,7 @@ Factory::setDefaultInstance(
         })
 );
 
-exceptionMessage(static fn() => Validator::stringType()->length(Validator::between(2, 15))->check(0));
+exceptionMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->check(0));
 ?>
 --EXPECT--
 0 deve ser do tipo string
diff --git a/tests/unit/FactoryTest.php b/tests/unit/FactoryTest.php
index 243ef672..096fd323 100644
--- a/tests/unit/FactoryTest.php
+++ b/tests/unit/FactoryTest.php
@@ -89,9 +89,9 @@ final class FactoryTest extends TestCase
         $factory = (new Factory())->withRuleNamespace(self::TEST_RULES_NAMESPACE);
 
         $this->expectException(ComponentException::class);
-        $this->expectExceptionMessage('"notFoundRule" is not a valid rule name');
+        $this->expectExceptionMessage('"nonExistingRule" is not a valid rule name');
 
-        $factory->rule('notFoundRule');
+        $factory->rule('nonExistingRule');
     }
 
     #[Test]
diff --git a/tests/unit/Transformers/PrefixTest.php b/tests/unit/Transformers/PrefixTest.php
new file mode 100644
index 00000000..247afaf5
--- /dev/null
+++ b/tests/unit/Transformers/PrefixTest.php
@@ -0,0 +1,105 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Transformers;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\Test;
+use Respect\Validation\Test\TestCase;
+
+#[Group('core')]
+#[CoversClass(Prefix::class)]
+final class PrefixTest extends TestCase
+{
+    #[Test]
+    #[DataProvider('providerForTransformedRuleSpec')]
+    public function itShouldTransformRuleSpec(RuleSpec $original, RuleSpec $expected): void
+    {
+        $transformer = new Prefix();
+        $transformed = $transformer->transform($original);
+
+        self::assertEquals($expected, $transformed);
+    }
+
+    #[Test]
+    #[DataProvider('providerForUntransformedRuleNames')]
+    public function itShouldPreventTransformingCanonicalRule(string $ruleName): void
+    {
+        $ruleSpec = new RuleSpec($ruleName);
+
+        $transformer = new Prefix();
+        self::assertSame($ruleSpec, $transformer->transform($ruleSpec));
+    }
+
+    /** @return array<array{RuleSpec, RuleSpec}> */
+    public static function providerForTransformedRuleSpec(): array
+    {
+        return [
+            'key' => [
+                new RuleSpec('keyNextRule', ['keyName', 123]),
+                new RuleSpec('NextRule', [123], new RuleSpec('key', ['keyName'])),
+            ],
+            'length' => [
+                new RuleSpec('lengthNextRule', [5]),
+                new RuleSpec('NextRule', [5], new RuleSpec('length')),
+            ],
+            'max' => [
+                new RuleSpec('maxNextRule', [1, 10]),
+                new RuleSpec('NextRule', [1, 10], new RuleSpec('max')),
+            ],
+            'min' => [
+                new RuleSpec('minNextRule', [1, 10]),
+                new RuleSpec('NextRule', [1, 10], new RuleSpec('min')),
+            ],
+            'not' => [
+                new RuleSpec('notNextRule', [1, 10]),
+                new RuleSpec('NextRule', [1, 10], new RuleSpec('not')),
+            ],
+            'nullOr' => [
+                new RuleSpec('nullOrNextRule', [1, 10]),
+                new RuleSpec('NextRule', [1, 10], new RuleSpec('nullable')),
+            ],
+            'property' => [
+                new RuleSpec('propertyNextRule', ['propertyName', 567]),
+                new RuleSpec('NextRule', [567], new RuleSpec('property', ['propertyName'])),
+            ],
+            'undefOr' => [
+                new RuleSpec('undefOrNextRule', [1, 10]),
+                new RuleSpec('NextRule', [1, 10], new RuleSpec('optional')),
+            ],
+        ];
+    }
+
+    /** @return array<array{string}> */
+    public static function providerForUntransformedRuleNames(): array
+    {
+        return [
+            'equals' => ['equals'],
+            'key' => ['key'],
+            'keyExists' => ['keyExists'],
+            'keyOptional' => ['keyOptional'],
+            'keySet' => ['keySet'],
+            'length' => ['length'],
+            'max' => ['max'],
+            'maxAge' => ['maxAge'],
+            'min' => ['min'],
+            'minAge' => ['minAge'],
+            'not' => ['not'],
+            'notBlank' => ['notBlank'],
+            'notEmoji' => ['notEmoji'],
+            'notEmpty' => ['notEmpty'],
+            'notOptional' => ['notOptional'],
+            'property' => ['property'],
+            'propertyExists' => ['propertyExists'],
+            'propertyOptional' => ['propertyOptional'],
+        ];
+    }
+}