Final Class Yiisoft\Validator\Rule\Nested

                public function __construct(
    iterable|object|string|null $rules = null,
    private int $validatedObjectPropertyVisibility = ReflectionProperty::IS_PRIVATE
    | ReflectionProperty::IS_PROTECTED
    | ReflectionProperty::IS_PUBLIC,
    private int $rulesSourceClassPropertyVisibility = ReflectionProperty::IS_PRIVATE
    | ReflectionProperty::IS_PROTECTED
    | ReflectionProperty::IS_PUBLIC,
    private string $noRulesWithNoObjectMessage = 'Nested rule without rules requires {property} to be an object. '
    . '{type} given.',
    private string $incorrectDataSetTypeMessage = 'An object data set data for {property} can only have an array '
    . 'type. {type} given.',
    private string $incorrectInputMessage = '{Property} must be an array or an object. {type} given.',
    private bool $requirePropertyPath = false,
    private string $noPropertyPathMessage = 'Property "{path}" is not found in {property}.',
    private bool $handleEachShortcut = true,
    private bool $propagateOptions = false,
    bool|callable|null $skipOnEmpty = null,
    private bool $skipOnError = false,
    private ?Closure $when = null,
) {
    $this->skipOnEmpty = $skipOnEmpty;
    $this->prepareRules($rules);
}

            

                public function afterInitAttribute(object $object): void
{
    if ($this->rules === null) {
        return;
    }
    foreach ($this->rules as $rules) {
        if (is_array($rules)) {
            foreach ($rules as $rule) {
                if ($rule instanceof AfterInitAttributeEventInterface) {
                    $rule->afterInitAttribute($object);
                }
            }
        } else {
            if ($rules instanceof AfterInitAttributeEventInterface) {
                $rules->afterInitAttribute($object);
            }
        }
    }
}

            

                public function getHandler(): string
{
    return NestedHandler::class;
}

            

                public function getIncorrectDataSetTypeMessage(): string
{
    return $this->incorrectDataSetTypeMessage;
}

            

                public function getIncorrectInputMessage(): string
{
    return $this->incorrectInputMessage;
}

            

                public function getName(): string
{
    return self::class;
}

            

                public function getNoPropertyPathMessage(): string
{
    return $this->noPropertyPathMessage;
}

            

                public function getNoRulesWithNoObjectMessage(): string
{
    return $this->noRulesWithNoObjectMessage;
}

            

                #[ArrayShape([
    'requirePropertyPath' => 'bool',
    'noRulesWithNoObjectMessage' => 'array',
    'incorrectDataSetTypeMessage' => 'array',
    'incorrectInputMessage' => 'array',
    'noPropertyPathMessage' => 'array',
    'skipOnEmpty' => 'bool',
    'skipOnError' => 'bool',
    'rules' => 'array|null',
])]
public function getOptions(): array
{
    return [
        'noRulesWithNoObjectMessage' => [
            'template' => $this->noRulesWithNoObjectMessage,
            'parameters' => [],
        ],
        'incorrectDataSetTypeMessage' => [
            'template' => $this->incorrectDataSetTypeMessage,
            'parameters' => [],
        ],
        'incorrectInputMessage' => [
            'template' => $this->incorrectInputMessage,
            'parameters' => [],
        ],
        'noPropertyPathMessage' => [
            'template' => $this->getNoPropertyPathMessage(),
            'parameters' => [],
        ],
        'requirePropertyPath' => $this->isPropertyPathRequired(),
        'skipOnEmpty' => $this->getSkipOnEmptyOption(),
        'skipOnError' => $this->skipOnError,
        'rules' => $this->rules === null ? null : RulesDumper::asArray($this->rules),
    ];
}

            

                public function getRules(): ?array
{
    return $this->rules;
}

            

                public function getValidatedObjectPropertyVisibility(): int
{
    return $this->validatedObjectPropertyVisibility;
}

            

                public function isPropertyPathRequired(): bool
{
    return $this->requirePropertyPath;
}

            

                public function propagateOptions(): void
{
    if ($this->rules === null) {
        return;
    }
    $rules = [];
    foreach ($this->rules as $attributeRulesIndex => $attributeRules) {
        $rules[$attributeRulesIndex] = is_iterable($attributeRules)
            ? PropagateOptionsHelper::propagate($this, $attributeRules)
            : PropagateOptionsHelper::propagateToRule($this, $attributeRules);
    }
    $this->rules = $rules;
}