Final Class Yiisoft\Validator\Rule\File

                public function __construct(
    array|string|null $extensions = null,
    array|string|null $mimeTypes = null,
    private ?int $size = null,
    private ?int $minSize = null,
    private ?int $maxSize = null,
    private bool $trustClientMediaType = false,
    private string $message = '{Property} must be a file.',
    private string $uploadFailedMessage = 'Failed to upload {property}. Error code: {error, number}.',
    private string $uploadRequiredMessage = 'Please upload a file.',
    private string $wrongExtensionMessage = 'Only files with these extensions are allowed: {extensions}.',
    private string $wrongMimeTypeMessage = 'Only files with these MIME types are allowed: {mimeTypes}.',
    private string $notExactSizeMessage = 'The size of {property} must be exactly {exactly, number} {exactly, plural, one{byte} other{bytes}}.',
    private string $tooSmallMessage = 'The size of {property} cannot be smaller than {limit, number} {limit, plural, one{byte} other{bytes}}.',
    private string $tooBigMessage = 'The size of {property} cannot be larger than {limit, number} {limit, plural, one{byte} other{bytes}}.',
    private string $unableToDetermineSizeMessage = 'The size of {property} cannot be determined.',
    bool|callable|null $skipOnEmpty = null,
    private bool $skipOnError = false,
    private ?Closure $when = null,
) {
    if ($this->size !== null && ($this->minSize !== null || $this->maxSize !== null)) {
        throw new InvalidArgumentException('Exact size and min / max size can\'t be specified together.');
    }
    foreach (['size' => $this->size, 'minSize' => $this->minSize, 'maxSize' => $this->maxSize] as $name => $value) {
        if ($value !== null && $value < 0) {
            throw new InvalidArgumentException(ucfirst($name) . ' must be greater than or equal to 0.');
        }
    }
    if ($this->minSize !== null && $this->maxSize !== null && $this->minSize > $this->maxSize) {
        throw new InvalidArgumentException('Min size must be less than or equal to max size.');
    }
    $this->extensions = $this->normalizeList($extensions);
    $this->mimeTypes = $this->normalizeList($mimeTypes);
    $this->skipOnEmpty = $skipOnEmpty;
}

            

                public function getExtensions(): ?array
{
    return $this->extensions;
}

            

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

            

                public function getMaxSize(): ?int
{
    return $this->maxSize;
}

            

                public function getMessage(): string
{
    return $this->message;
}

            

                public function getMimeTypes(): ?array
{
    return $this->mimeTypes;
}

            

                public function getMinSize(): ?int
{
    return $this->minSize;
}

            

                public function getName(): string
{
    return 'file';
}

            

                public function getNotExactSizeMessage(): string
{
    return $this->notExactSizeMessage;
}

            

                public function getOptions(): array
{
    return [
        'extensions' => $this->extensions,
        'mimeTypes' => $this->mimeTypes,
        'trustClientMediaType' => $this->trustClientMediaType,
        'size' => $this->size,
        'minSize' => $this->minSize,
        'maxSize' => $this->maxSize,
        'message' => [
            'template' => $this->message,
            'parameters' => [],
        ],
        'uploadFailedMessage' => [
            'template' => $this->uploadFailedMessage,
            'parameters' => [],
        ],
        'uploadRequiredMessage' => [
            'template' => $this->uploadRequiredMessage,
            'parameters' => [],
        ],
        'wrongExtensionMessage' => [
            'template' => $this->wrongExtensionMessage,
            'parameters' => [],
        ],
        'wrongMimeTypeMessage' => [
            'template' => $this->wrongMimeTypeMessage,
            'parameters' => [],
        ],
        'notExactSizeMessage' => [
            'template' => $this->notExactSizeMessage,
            'parameters' => [],
        ],
        'tooSmallMessage' => [
            'template' => $this->tooSmallMessage,
            'parameters' => [],
        ],
        'tooBigMessage' => [
            'template' => $this->tooBigMessage,
            'parameters' => [],
        ],
        'unableToDetermineSizeMessage' => [
            'template' => $this->unableToDetermineSizeMessage,
            'parameters' => [],
        ],
        'skipOnEmpty' => $this->getSkipOnEmptyOption(),
        'skipOnError' => $this->skipOnError,
    ];
}

            

                public function getSize(): ?int
{
    return $this->size;
}

            

                public function getSkipOnEmpty(): bool|callable|null
{
    if ($this->skipOnEmpty === true || $this->skipOnEmpty instanceof WhenEmpty) {
        $emptyCondition = $this->skipOnEmpty === true ? new WhenEmpty() : $this->skipOnEmpty;
        return static fn(mixed $value, bool $isPropertyMissing): bool => self::isUploadMissing($value)
            || $emptyCondition($value, $isPropertyMissing);
    }
    return $this->skipOnEmpty;
}

            

                public function getTooBigMessage(): string
{
    return $this->tooBigMessage;
}

            

                public function getTooSmallMessage(): string
{
    return $this->tooSmallMessage;
}

            

                public function getTrustClientMediaType(): bool
{
    return $this->trustClientMediaType;
}

            

                public function getUnableToDetermineSizeMessage(): string
{
    return $this->unableToDetermineSizeMessage;
}

            

                public function getUploadFailedMessage(): string
{
    return $this->uploadFailedMessage;
}

            

                public function getUploadRequiredMessage(): string
{
    return $this->uploadRequiredMessage;
}

            

                public function getWrongExtensionMessage(): string
{
    return $this->wrongExtensionMessage;
}

            

                public function getWrongMimeTypeMessage(): string
{
    return $this->wrongMimeTypeMessage;
}