Laminas Validator

https://github.com/laminas/laminas-validator
Admin
Provides a set of commonly needed validators and a simple validator chaining mechanism to apply...
Tokens:113,988
Snippets:847
Trust Score:9.7
License:BSD-3-Clause
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install packages for command line example

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/undisclosed-password.md

Installs required packages for the command line example, including laminas-diactoros and php-http/curl-client.

```bash
$ composer require \
    php-http/message \
    php-http/message-factory \
    php-http/discovery \
    php-http/curl-client \
    laminas/laminas-diactoros \
    laminas/laminas-validator
```

--------------------------------

### Install laminas-i18n via Composer

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/intro.md

Required before using translation features. Run this command to install the laminas-i18n component.

```bash
$ composer require laminas/laminas-i18n
```

--------------------------------

### Install laminas-validator with Composer

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/README.md

Use Composer to install the laminas-validator library. Run this command in your project directory to add the dependency.

```bash
$ composer require laminas/laminas-validator
```

--------------------------------

### Construct Hash validator with algorithm

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/migration/v2-to-v3.md

Example of constructing the Hash validator directly with a specific algorithm and hash value, replacing the removed Crc32, Md5, and Sha1 inheritors. The available algorithms depend on the PHP installation and can be listed with hash_algos().

```php
$hash = new \Laminas\Validator\File\Hash([
    'hash' => 'SomeExpectedSha256Hash',
    'algorithm' => 'sha256',
]);

$hash->isValid('/path/to/file.md');
```

--------------------------------

### Run the command line example

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/undisclosed-password.md

Executes the undisclosed.php script using the PHP CLI.

```bash
$ php undisclosed.php
```

--------------------------------

### Install laminas-i18n-resources via Composer

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/messages.md

Command to install the package providing pre-translated validation messages for over 45 validators and 200+ failure messages.

```bash
$ composer require laminas/laminas-i18n-resources
```

--------------------------------

### Expected output from command line example

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/undisclosed-password.md

Shows the output of running the script: both passwords are disclosed.

```bash
Password "password" is disclosed
Password "NVt3MpvQ" is not disclosed
```

--------------------------------

### Integer Keys Casting Example

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/key-exists.md

PHP casts numeric strings to integers when used as array keys, and this validator follows the same behavior. The example shows that a key of '2' matches the integer key 2 in the array.

```php
$array = ['1' => 'Foo'];
// Becomes [1 => 'Foo'];
```

```php
$validator = new Laminas\Validator\KeyExists([
    'key' => '2',
]);

$validator->isValid(['a', 'b', 'c']); // true
```

--------------------------------

### String Decimal Key Example

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/key-exists.md

Using a floating point number as a key is not supported because PHP casts floats to integers (with deprecation), but a string decimal is supported. The example shows that a key of '1.42' matches the string key '1.42' in the array.

```php
$validator = new Laminas\Validator\KeyExists([
    'key' => '1.42',
]);

$validator->isValid(['1.0' => 'a', '1.42' => 'b']); // true
```

--------------------------------

### Command line example script (undisclosed.php)

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/undisclosed-password.md

Creates a script that uses the validator with laminas-diactoros and php-http/curl-client. Outputs whether each password is disclosed.

```php
require_once __DIR__ . '/vendor/autoload.php';

use Http\Client\Curl\Client;
use Laminas\Diactoros\RequestFactory;
use Laminas\Diactoros\ResponseFactory;
use Laminas\Validator\UndisclosedPassword;

$requestFactory = new RequestFactory();
$responseFactory = new ResponseFactory();
$client = new Client($responseFactory, null);

$undisclosedPassword = new UndisclosedPassword($client, $requestFactory);
echo 'Password "password" is ' . ($undisclosedPassword->isValid('password') ? 'not disclosed' : 'disclosed') . PHP_EOL;
echo 'Password "NVt3MpvQ" is ' . ($undisclosedPassword->isValid('NVt3MpvQ') ? 'not disclosed' : 'disclosed') . PHP_EOL;
```

--------------------------------

### Example validator with service dependency

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/writing-validators.md

Shows a complete validator class and its factory. The validator resolves options to a readonly property and uses a service for validation. The factory injects the service and passes options to the constructor.

```php
namespace MyValid;

use Laminas\Validator\AbstractValidator;
use Psr\Container\ContainerInterface;

/**
 * @psalm-type Options = array{
 *     allowIcao?: bool,
 * }
 */
final class FlightNumber extends AbstractValidator {
    
    public const ERR_INVALID_FLIGHT_NUMBER = 'invalidFlightNumber';
    
    private readonly $allowIcao;
    
    public function __construct(
        private readonly FlightNumberValidationService $service,
        array $options = [],
    ) {
        $this->allowIcao = $options['allowIcao'] ?? true;
        
        parent::__construct($options);
    }
    
    public function isValid(mixed $value): bool
    {
        if (! is_string($value)) {
            $this->error(self::ERR_INVALID_FLIGHT_NUMBER);
            
            return false;
        }
        
        if (! $this->service->isValidFlightNumber($value, $this->allowIcao)) {
            $this->error(self::ERR_INVALID_FLIGHT_NUMBER);
            
            return false;
        }
        
        return true;
    }
}

final class FlightNumberFactory
{
    public function __invoke(ContainerInterface $container, string $name, array $options = []): FlightNumber
    {
        return new FlightNumber(
            $container->get(FlightNumberValidationService::class),
            $options,
        );
    }
}
```

--------------------------------

### Validating Arbitrary Filenames with allowNonExistentFile

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/extension.md

Allows validation of filenames that do not exist on the filesystem by setting 'allowNonExistentFile' to true. The example shows that 'picture.jpg' passes and 'something-else.txt' fails.

```php
use Laminas\Validator\File\Extension;

$validator = new Extension([
    'extension' => 'gif,jpg,png',
    'allowNonExistentFile' => true,
]);

$validator->isValid('picture.jpg'); // true
$validator->isValid('something-else.txt'); // false
```

--------------------------------

### Install PSR-18 and PSR-17 packages

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/undisclosed-password.md

Required before using the validator. Installs the HTTP client and request factory interfaces.

```bash
$ composer require psr/http-client
$ composer require psr/http-factory
```

--------------------------------

### Allow multiple credit card types with CreditCard::AMERICAN_EXPRESS and CreditCard::VISA

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/credit-card.md

Accepts multiple specific card institutes by providing an array of type constants. This example allows American Express and Visa only.

```php
use Laminas\Validator\CreditCard;

$valid = new CreditCard([
    'type' => [
        CreditCard::AMERICAN_EXPRESS,
        CreditCard::VISA
    ],
]);
```

--------------------------------

### Explode Constructor

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/explode.md

Creates an Explode validator instance with the provided options. Options include the delimiter, the composed validator, and the validator plugin manager.

```APIDOC
## Explode Constructor

### Description
Creates an Explode validator instance with the provided options. Options include the delimiter, the composed validator, and the validator plugin manager.

### Method
__construct

### Signature
`public function __construct(iterable|array|Traversable $options = [])`

### Parameters
- **options** (iterable|array|Traversable) - Optional - Configuration options. Supported options:
  - `valueDelimiter` (string) - Optional - Delimiter used to explode values. Defaults to `,`.
  - `validator` (validator instance|string|array) - Optional - The validator to execute on each exploded item. Can be a validator instance, a validator service name, or a specification array.
  - `validatorPluginManager` (ValidatorPluginManager) - Optional - The validator plugin manager to use. If not provided, a default one is created.

### Example
```php
$explodeValidator = new Laminas\Validator\Explode([
    'validator' => $inArrayValidator
]);
```
```

--------------------------------

### Configuring NotEmpty type with constants and arrays

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/not-empty.md

Shows different ways to specify which types are considered empty: using a single constant, bitwise OR, an array of constants, or an array of strings. All examples return false on 0 or '0'.

```php
use Laminas\Validator\NotEmpty;

// Returns false on 0
$validator = new NotEmpty(['type' => NotEmpty::INTEGER]);

// Returns false on 0 or '0'
$validator = new NotEmpty(['type' => NotEmpty::INTEGER | NotEmpty::ZERO]);

// Returns false on 0 or '0'
$validator = new NotEmpty(['type' => [ NotEmpty::INTEGER, NotEmpty::ZERO ]]);

// Returns false on 0 or '0'
$validator = new NotEmpty(['type' => ['integer', 'zero']]);
```

--------------------------------

### Basic Extension Validation with Case-Insensitive Matching

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/extension.md

Validates file extensions against a list, case-insensitively by default. The example shows that 'file.PHP' passes when 'case' is not set (defaults to false).

```php
use Laminas\Validator\File\Extension;

$validator = new Extension([
    'extension' => ['php', 'exe'],
]);

$validator->isValid('./file.php'); // true
$validator->isValid('./file.PHP'); // true

$validator = new Extension([
    'extension' => 'php,exe',
    'case' => true,
]);

$validator->isValid('./file.php'); // true
$validator->isValid('./file.PHP'); // false
```

--------------------------------

### Accept DNS and local hostnames with Hostname::ALLOW_DNS | Hostname::ALLOW_LOCAL

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/email-address.md

Instantiate EmailAddress with an 'allow' option to accept both DNS and local hostnames. The example then validates an email and prints validation messages.

```php
use Laminas\Validator\EmailAddress;
use Laminas\Validator\Hostname;

$validator = new EmailAddress([
    'allow' => Hostname::ALLOW_DNS | Hostname::ALLOW_LOCAL 
]);

if ($validator->isValid($email)) {
    // email appears to be valid
} else {
    // email is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}
```

--------------------------------

### Best Practice: Get Validator Chain from Application-Wide Plugin Manager

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validator-chains.md

Recommended approach to avoid mismatched plugin manager instances: retrieve the ValidatorPluginManager from the container, then get the ValidatorChain and attach a NotEmpty validator instance. Avoid manually calling new ValidatorChain().

```php
use Psr\Container\ContainerInterface;
use Laminas\Validator\NotEmpty;
use Laminas\Validator\ValidatorChain;
use Laminas\Validator\ValidatorPluginManager;

/** @var ContainerInterface $container */

$pluginManager = $container->get(ValidatorPluginManager::class);

$chain = $pluginManager->get(ValidatorChain::class);
$chain->attach(
    $pluginManager->get(NotEmpty::class),
);
```

--------------------------------

### Custom barcode adapter implementation and usage

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/barcode.md

Defines a custom barcode adapter that expects an even number of digits and requires a checksum. The adapter implements Laminas\Validator\Barcode\AdapterInterface and is used with Laminas\Validator\Barcode. The example includes the adapter class and its instantiation with the validator.

```php
namespace My\Barcode;

use Laminas\Validator\Barcode;
use Laminas\Validator\Barcode\AdapterInterface;use function ctype_digit;

final class CustomBarcodeAdapter implements AdapterInterface
{
    public function hasValidLength(string $value): bool
    {
        return strlen($value) % 2 === 0;
    }

    public function hasValidCharacters(string $value): bool
    {
        return ctype_digit($value);
    }

    public function hasValidChecksum(string $value): bool
    {
        // do some validation and return a boolean
        return true;
    }

    public function getLength(): string
    {
        return 'even';
    }
}

$validator = new Barcode([
    'adapter' => CustomBarcodeAdapter::class,
]);

if ($validator->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}
```

--------------------------------

### Using $context parameter with Laminas\Validator\Identical

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/identical.md

When used with laminas-inputfilter, the payload is passed as $context. A string token key is looked up in $context when available. The example shows validation against the context value.

```php
$context = [
    'first' => 'donkey',
    'second' => 'goat',
    'input' => 'cat',
];
$validator = new Laminas\Validator\Identical(['token' => 'first');

$validator->isValid($formPayload['input'], $context); // false - 'cat' !== 'donkey'
$validator->isValid('donkey', $context); // true
```

--------------------------------

### new Laminas\Validator\Isbn()

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/isbn.md

Creates an ISBN validator instance. By default, it validates both ISBN-10 and ISBN-13 numbers, with or without separators.

```APIDOC
## Constructor

### Description
Creates an ISBN validator instance.

### Parameters
- **options** (array) - Optional - An array of options. Supported option: `type` (string) - Defines the allowed ISBN types. Defaults to `Laminas\Validator\Isbn::AUTO`.

### Example
```php
$validator = new Laminas\Validator\Isbn();
```
```

--------------------------------

### Basic callback function definition

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/callback.md

Defines a simple callback function that returns a boolean. This is the function used in the basic usage example.

```php
function myMethod(mixed $value): bool
{
    // some validation
    return true;
}
```

--------------------------------

### Add user-defined callback arguments with callbackOptions

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/callback.md

Shows how to pass additional arguments to the callback via the 'callbackOptions' option. The callback receives the value, context, and the injected service. The example validates using a MuppetService and returns true for 'Fozzie Bear' with context 'muppet-2' as 'Scooter'. There is no limit on the number of arguments.

```php
use Laminas\Validator\Callback;

$validator = new Callback([
    'callback' => static function (mixed $value, array $context = [], MuppetService $service): bool {
        if ($service->isKnownMuppet($value) && $service->isKnownMuppet($context['muppet-2'] ?? null)) {
            return true;
        }
        
        return false;
    },
    'callbackOptions' => [
        'service' => new MuppetService(),    
    ],
]);

$validator->isValid('Fozzie Bear', ['muppet-2' => 'Scooter']);
```

--------------------------------

### Default NotEmpty validation with empty string

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/not-empty.md

By default, the validator treats both integer 0 and string '0' as empty. This example shows that an empty string returns false.

```php
$valid = new Laminas\Validator\NotEmpty();
$value  = '';
$result = $valid->isValid($value);
// returns false
```

--------------------------------

### Setting Validator Chain Order with Priorities

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validator-chains.md

Shows how to attach validators to a ValidatorChain with priorities to control execution order. Higher priority values execute earlier; the example uses priorities 1 and 2 to run the 7-9 character check before the 3-5 check. The chain breaks on failure and outputs a message if validation fails.

```php
use Laminas\Validator\StringLength;
use Laminas\Validator\ValidatorChain;

$username = 'ABCDFE';

// Create a validator chain and add validators to it
$validatorChain = new ValidatorChain();
$validatorChain->attach(
    new StringLength(['min' => 3, 'max' => 5]),
    true, // break chain on failure
    1
);
$validatorChain->attach(
    new StringLength(['min' => 7, 'max' => 9]),
    true, // break chain on failure
    2     // higher priority!
);

// Validate the username
if ($validatorChain->isValid($username)) {
    // username passed validation
    echo "Success";
} else {
    // username failed validation; print reasons
    foreach ($validatorChain->getMessages() as $message) {
        echo "$message\n";
    }
}

// This first example will display: The input is less than 7 characters long
```

--------------------------------

### Validating Uploaded Files with NotExists

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/not-exists.md

Validates uploaded files (from $_FILES or PSR-7 UploadedFileInterface) against the NotExists validator. If the directory option is unset, validation fails for successfully uploaded files; when a directory is provided, the directories are searched for the base name of the uploaded file path. The example assumes $files is a single successful upload in $_FILES format.

```php
use Laminas\Validator\File\NotExists;

$validator = new NotExists();
$validator->isValid($files); // False - the uploaded file exists (Of course)

$validator = new NotExists([
    'directory' => [
        '/home/files',
        '/tmp',
    ],
]);

if ($validator->isValid($files)) {
    // The basename of the uploaded file could not be found in any of the directories
} else {
    // The basename of the uploaded file was located in at least 1 of the directories
}
```

--------------------------------

### Specify minimum count with 'min' option

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-countable.md

Sets a minimum count of 2. Validation passes when the value is countable and its count is greater than or equal to the minimum.

```php
$validator = new Laminas\Validator\IsCountable(['min' => 2]);

$validator->isValid([1, 2, 3]);                  // true; countable, and count is 3
$validator->isValid(new ArrayObject([1, 2, 3])); // true; countable, and count is 3
$validator->isValid([1, 2]);                     // true; countable, and count is 2
$validator->isValid(new ArrayObject([1, 2]));    // true; countable, and count is 2
$validator->isValid([1]);                        // false; countable, but count is 1
$validator->isValid(new ArrayObject([1]));       // false; countable, but count is 1
```

--------------------------------

### Specify both minimum and maximum count range

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-countable.md

Sets both 'min' and 'max' options to validate that the count is between the two values inclusively. Cannot be combined with the 'count' option.

```php
$validator = new Laminas\Validator\IsCountable([
    'min' => 3,
    'max' => 5,
]);

$validator->isValid([1, 2, 3]);                    // true; countable, and count is 3
$validator->isValid(new ArrayObject([1, 2, 3]));   // true; countable, and count is 3
$validator->isValid(range(1, 5));                  // true; countable, and count is 5
$validator->isValid(new ArrayObject(range(1, 5))); // true; countable, and count is 5
$validator->isValid([1, 2]);                       // false; countable, and count is 2
$validator->isValid(new ArrayObject([1, 2]));      // false; countable, and count is 2
$validator->isValid(range(1, 6));                  // false; countable, and count is 6
$validator->isValid(new ArrayObject(range(1, 6))); // false; countable, and count is 6
```

--------------------------------

### Configuration Using a Validator Specification

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/explode.md

Configures the Explode validator with a specification array instead of a validator instance. The 'validator' key uses the InArray class name with options for the haystack, and 'valueDelimiter' is set to ';'. The isValid method returns true for 'a;b' and false for 'x;y;z' because 'x', 'y', and 'z' are not in the haystack.

```php
$explodeValidator = new Laminas\Validator\Explode([
    'validator' => [
        'name' => Laminas\Validator\InArray::class,
        'options' => [
            'haystack' => ['a', 'b', 'c']
        ],
    ],
    'valueDelimiter' => ';',
]);

$explodeValidator->isValid('a;b'); // returns true
$explodeValidator->isValid('x;y;z');  // returns false
```

--------------------------------

### Basic Usage of Laminas\Validator\File\ImageSize

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/image-size.md

Shows how to instantiate the ImageSize validator with various dimension constraints and perform validation on a file path. The options minWidth, minHeight, maxWidth, and maxHeight are integers or null (default) to indicate no limit.

```php
use Laminas\Validator\File\ImageSize;

// Is image size between 320x200 (min) and 640x480 (max)?
$validator = new ImageSize([
    'minWidth' => 320,
    'minHeight' => 200,
    'maxWidth' => 640,
    'maxHeight' => 480,
]);

// Is image size equal to or larger than 320x200?
$validator = new ImageSize([
    'minWidth' => 320,
    'minHeight' => 200,
]);

// Is image size equal to or smaller than 640x480?
$validator = new ImageSize([
    'maxWidth' => 640,
    'maxHeight' => 480,
]);

// Perform validation with file path
if ($validator->isValid('./myfile.jpg')) {
    // file is valid
}
```

--------------------------------

### ISBN validation with separators stripped

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/isbn.md

The validator strips spaces and dashes before validation, so ISBNs formatted with either separator are accepted. The example shows that '0060929871', '0-06-092987-1', and '0 06 092987 1' all return true.

```php
$validator = new Laminas\Validator\Isbn();

$validator->isValid('0060929871'); // true
$validator->isValid('0-06-092987-1'); // true
$validator->isValid('0 06 092987 1'); // true
```

--------------------------------

### Constructor accepting options array

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/writing-validators.md

Define the constructor to accept an associative array of options and call parent::__construct($options) to ensure the 'messages' option overrides defaults. This also improves compatibility with ValidatorPluginManager.

```php
public function __construct(array $options) { /** ... **/}
```

--------------------------------

### Retrieve all message templates with getMessageTemplates()

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/messages.md

Use getMessageTemplates() on a validator instance to get an array of all possible failure messages.

```php
$validator = new Laminas\Validator\Digits();
$messages  = $validator->getMessageTemplates();
```

--------------------------------

### new Exists(options)

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/exists.md

Creates an instance of the Exists validator to check for the existence of files in specified directories. The constructor accepts an options array with 'directory' and 'all' keys.

```APIDOC
## Constructor: new Exists(options)

### Description
Creates an instance of the Exists validator to check for the existence of files in specified directories.

### Parameters
#### Options Array
- **directory** (array|string) - Optional - Array of directories, or comma-delimited string of directories.
- **all** (boolean) - Optional - When `true` (default), requires that the filename is present in **all** listed directories; when `false`, allows existence in any of the listed directories.

### Usage Example
```php
use Laminas\Validator\File\Exists;

// Only allow files that exist in ~both~ directories
$validator = new Exists(['directory' => '/tmp,/var/tmp']);

if ($validator->isValid('myfile.txt')) {
    // file is present in all directories
} else {
    // file was not present in at least 1 of the directories
}
```

```php
use Laminas\Validator\File\Exists;

// Allow files that exist in any of the listed directories
$validator = new Exists([
    'directory' => ['/tmp', '/var/tmp'],
    'all' => false,
]);

if ($validator->isValid('myfile.txt')) {
    // file was found in at least 1 directory
} else {
    // file was not found in one of the directories
}
```

```php
use Laminas\Validator\File\Exists;

// Check the value for existence without a directory option
$validator = new Exists();

if ($validator->isValid('/path/to/myfile.txt')) {
    // file exists
}
```
```

--------------------------------

### Validate Less Than Max Only

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/number-comparison.md

Omits min or sets it to null to validate numbers less than an upper bound. Example: 99 is invalid with max 5.

```php
$validator = new Laminas\Validator\NumberComparison(['max' => 5]);
$validator->isValid(99); // false
```

--------------------------------

### new MimeType(options)

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/mime-type.md

Creates a new MimeType validator instance. The constructor accepts an options array with a 'mimeType' key that can be a comma-delimited string or an array of MIME types to validate against.

```APIDOC
## Constructor: new MimeType(options)

### Description
Creates a new MimeType validator instance. The constructor accepts an options array with a 'mimeType' key that can be a comma-delimited string or an array of MIME types to validate against.

### Parameters
#### Options Array
- **mimeType** (string|array) - Required - Comma-delimited string of MIME types, or array of MIME types, against which to test. Types can be specific (e.g., `image/jpeg`), or refer only to the group (e.g., `image`).

### Request Example
```php
use Laminas\Validator\File\MimeType;

// Only allow 'gif' or 'jpg' files
$validator = new MimeType(['mimeType' => 'image/gif,image/jpeg']);

// ... or with array notation:
$validator = new MimeType(['mimeType' => ['image/gif', 'image/jpeg']]);

// ... or restrict to entire group of types:
$validator = new MimeType(['mimeType' => ['image', 'audio']]);
```

### Response
#### Success Response
Returns a new MimeType validator instance.

### Notes
- **Compatibility**: This component makes use of the `FileInfo` extension which is enabled by default in PHP. If you are using a version of PHP that was explicitly built without the File Info extension, this validator will not work.
- **Warning**: Allowing "groups" of MIME types will accept **all** members of this group, even if your application does not support them. For instance, when you allow `image` you also allow `image/xpixmap` and `image/vasa`, both of which could be problematic.
```

--------------------------------

### Validate Greater Than Min Only

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/number-comparison.md

Omits max or sets it to null to validate numbers greater than a lower bound. Example: 12345 is valid with min 10.

```php
$validator = new Laminas\Validator\NumberComparison(['min' => 10, 'max' => null]);
$validator->isValid(12345); // true
```

--------------------------------

### Basic usage of Laminas\Validator\IsJsonString

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-json-string.md

Validates whether a given value is a string that can be successfully decoded by json_decode. The example checks a JSON string and branches on the result.

```php
$validator = new Laminas\Validator\IsJsonString();
$input = '{"some":"json"}';

if ($validator->isValid($input)) {
    // $input can be successfully decoded
} else {
    // $input is not a valid JSON string
}
```

--------------------------------

### Default Date Validation with Laminas\Validator\Date

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/date.md

Validates a date using the default format 'Y-m-d'. The example shows that '2000-10-10' returns true, while '10.10.2000' returns false.

```php
$validator = new Laminas\Validator\Date();

$validator->isValid('2000-10-10');   // returns true
$validator->isValid('10.10.2000'); // returns false
```

--------------------------------

### Laminas\Validator\NotEmpty constructor

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/not-empty.md

Creates a new NotEmpty validator instance. Accepts an options array with a 'type' key to configure which types are considered empty.

```APIDOC
## [METHOD] __construct

### Description
Creates a new NotEmpty validator instance. Accepts an options array with a 'type' key to configure which types are considered empty.

### Method
__construct

### Endpoint
Laminas\Validator\NotEmpty::__construct

### Parameters
#### Method Parameters
- **options** (array) - Optional - An array of options. The 'type' key sets the validation type(s).

### Request Example
```php
$validator = new Laminas\Validator\NotEmpty(['type' => NotEmpty::INTEGER]);
```

### Response
#### Success Response (instance)
- Returns a new NotEmpty validator instance.

#### Response Example
```php
$validator = new Laminas\Validator\NotEmpty();
```
```

--------------------------------

### isValid($value)

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/isbn.md

Validates the given ISBN value. Returns true if the value is a valid ISBN according to the configured type, false otherwise.

```APIDOC
## isValid($value)

### Description
Validates the given ISBN value.

### Parameters
- **value** (string) - Required - The ISBN value to validate.

### Return Value
- **bool** - Returns true if the value is valid, false otherwise.

### Example
```php
$validator = new Laminas\Validator\Isbn();
$validator->isValid('0060929871'); // true
$validator->isValid('0-06-092987-1'); // true
$validator->isValid('0 06 092987 1'); // true
```
```

--------------------------------

### Configure CreditCard validator with service callback

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/credit-card.md

Provides a callback in the 'service' option to invoke an online API after generic validation passes. The callback receives the card number, validation context, and accepted types. This prevents API calls for invalid numbers.

```php
use Laminas\Validator\CreditCard;

// Your service class
class CcService
{
    public function checkOnline(string $cardNumber, array $context, array $types): bool
    {
        // some online validation
    }
}

// The validation
$service = new CcService();
$valid   = new CreditCard([
    'type' => CreditCard::VISA,
    'service' => [$service, 'checkOnline'],
]);
```

--------------------------------

### Basic ISBN validation with Laminas\Validator\Isbn

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/isbn.md

Validates any ISBN-10 or ISBN-13 value, with or without separators. The validator defaults to Laminas\Validator\Isbn::AUTO, which accepts both types.

```php
$validator = new Laminas\Validator\Isbn();

if ($validator->isValid($isbn)) {
    // isbn is valid
} else {
    // isbn is not valid
}
```

--------------------------------

### Specify exact count with 'count' option

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-countable.md

Configures the validator with an exact count of 3. Validation passes only when the countable value has exactly that count.

```php
$validator = new Laminas\Validator\IsCountable(['count' => 3]);

$validator->isValid([1, 2, 3]);                  // true; countable, and count is 3
$validator->isValid(new ArrayObject([1, 2, 3])); // true; countable, and count is 3
$validator->isValid([1]);                        // false; countable, but count is 1
$validator->isValid(new ArrayObject([1]));       // false; countable, but count is 1
```

--------------------------------

### Check file exists in any directory with Exists validator and all=false

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/exists.md

Uses an array of directories and sets 'all' to false, so validation passes if the file exists in at least one of the listed directories.

```php
use Laminas\Validator\File\Exists;

// Allow files that exist in any of the listed directories
$validator = new Exists([
    'directory' => ['/tmp', '/var/tmp'],
    'all' => false,
]);

if ($validator->isValid('myfile.txt')) {
    // file was found in at least 1 directory
} else {
    // file was not found in one of the directories
}
```

--------------------------------

### Explode::isValid

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/explode.md

Executes the composed validator on each item exploded from the input value. Returns true if all items pass validation, false otherwise.

```APIDOC
## Explode::isValid

### Description
Executes the composed validator on each item exploded from the input value. Returns true if all items pass validation, false otherwise.

### Method
isValid

### Signature
`public function isValid(mixed $value, ?array $context = null): bool`

### Parameters
- **value** (mixed) - Required - The value to validate. It will be exploded using the configured delimiter.
- **context** (?array) - Optional - The validation context (e.g., the entire payload when used via laminas-inputfilter). Passed to the composed validator.

### Return Value
- **bool** - Returns true if all exploded items pass validation, false otherwise.

### Example
```php
$explodeValidator->isValid('1,4,6');    // returns true
$explodeValidator->isValid('1,4,6,8'); // returns false
```
```

--------------------------------

### Create and Configure Validator Chains with ValidatorPluginManager

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validator-chains.md

Shows how to obtain an empty ValidatorChain from the ValidatorPluginManager and attach validators by name, or build a chain from an array of configuration with options like break_chain_on_failure and priority.

```php
use Laminas\Validator\ValidatorChain;
use Laminas\Validator\ValidatorPluginManager;

/** @var ValidatorPluginManager $pluginManager */

// Create an empty chain and then add validators:
$emptyChain = $pluginManager->get(ValidatorChain::class);
$emptyChain->attachByName(NotEmpty::class);;

// Or, "Build" a chain from an array of configuration:
$configuredChain = $pluginManager->build(ValidatorChain::class, [
    'notEmpty' => [
        'name' => NotEmpty::class,
        'break_chain_on_failure' => true,
        'options' => [],
        'priority' => 1,
    ],
]);
```

--------------------------------

### Pass context manually to CreditCard validator with closure service

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/credit-card.md

Shows standalone usage where the context must be provided manually. The service is a closure that returns true. The validator's isValid method is called with the card value and the full form payload as context.

```php
use Laminas\Validator\CreditCard;

$formPayload = [
    'card' => '4444 4444 4444 4444',
    'other-value' => 'Foo',
];

$validator = new CreditCard([
    'type' => CreditCard::VISA,
    'service' => static function (mixed $value, array $context = [], array $types = []): bool {
        return true;
    },
]);

$validator->isValid($formPayload['card'], $formPayload);
```

--------------------------------

### Validate lastmod with Laminas\Validator\Sitemap\Lastmod

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/sitemap.md

Checks if a string is a valid W3C date string for the 'lastmod' element. Returns true for valid dates and false for invalid ones, as shown in the examples.

```php
$validator = new Laminas\Validator\Sitemap\Lastmod();

$validator->isValid('1999-11-11T22:23:52-02:00'); // true
$validator->isValid('2008-05-12T00:42:52+02:00'); // true
$validator->isValid('1999-11-11'); // true
$validator->isValid('2008-05-12'); // true

$validator->isValid('1999-11-11t22:23:52-02:00'); // false
$validator->isValid('2008-05-12T00:42:60+02:00'); // false
$validator->isValid('1999-13-11'); // false
$validator->isValid('2008-05-32'); // false
$validator->isValid('yesterday'); // false
```

--------------------------------

### new Laminas\Validator\Ip()

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/ip.md

Creates an Ip validator instance. The constructor accepts an array of options to configure which IP address types are allowed.

```APIDOC
## Constructor: `new Laminas\Validator\Ip(array $options = [])`

### Description
Creates a new instance of the `Laminas\Validator\Ip` validator. The options array can be used to configure the validator's behavior.

### Parameters
#### Options Array
- **allowipv4** (bool) - Optional - Defines if the validator allows IPv4 addresses. Defaults to `true`.
- **allowipv6** (bool) - Optional - Defines if the validator allows IPv6 addresses. Defaults to `true`.
- **allowipvfuture** (bool) - Optional - Defines if the validator allows IPvFuture addresses. Defaults to `false`.
- **allowliteral** (bool) - Optional - Defines if the validator allows IPv6 or IPvFuture with URI literal style (the IP surrounded by brackets). Defaults to `true`.

### Example
```php
$validator = new Laminas\Validator\Ip(['allowipv6' => false]);
```
```

--------------------------------

### Region Aware IBAN Validation with country_code

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/iban.md

Validates an IBAN against a specific country's format by providing the 'country_code' option during instantiation. The example uses 'AT' for Austria.

```php
$validator = new Laminas\Validator\Iban(['country_code' => 'AT']);

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}
```

--------------------------------

### setOptions($options)

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/ip.md

Sets the validator options after instantiation. This allows changing the allowed IP address types dynamically.

```APIDOC
## Method: `setOptions($options)`

### Description
Updates the validator's options. This method can be used to change the allowed IP address types after the validator has been created.

### Parameters
- **options** (array) - Required - An array of options to set. The same options as the constructor are supported.

### Return Value
- **void** - This method does not return a value.

### Example
```php
$validator = new Laminas\Validator\Ip();
$validator->setOptions(['allowipv6' => false]);
```
```

--------------------------------

### Specify maximum count with 'max' option

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-countable.md

Sets a maximum count of 2. Validation passes when the value is countable and its count is less than or equal to the maximum.

```php
$validator = new Laminas\Validator\IsCountable(['max' => 2]);

$validator->isValid([1, 2, 3]);                  // false; countable, but count is 3
$validator->isValid(new ArrayObject([1, 2, 3])); // false; countable, but count is 3
$validator->isValid([1, 2]);                     // true; countable, and count is 2
$validator->isValid(new ArrayObject([1, 2]));    // true; countable, and count is 2
$validator->isValid([1]);                        // true; countable, and count is 1
$validator->isValid(new ArrayObject([1]));       // true; countable, and count is 1
```

--------------------------------

### Basic IP validation with Laminas\Validator\Ip

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/ip.md

Creates an Ip validator with default options (allows IPv4 and IPv6, IPvFuture disabled, literal style enabled) and checks if a value is a valid IP address. If invalid, the reasons can be retrieved from the validator's messages.

```php
$validator = new Laminas\Validator\Ip();

if ($validator->isValid($ip)) {
    // ip appears to be valid
} else {
    // ip is invalid; print the reasons
}
```

--------------------------------

### Extension Validator

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/extension.md

Validates that a file's extension matches one of the allowed extensions. Supports case sensitivity and validation of non-existent files.

```APIDOC
## Extension Validator

### Description
Checks the extension of files and asserts true when a given file matches any of the defined extensions. This validator is inversely related to the ExcludeExtension validator.

### Constructor
`new Extension(array $options)`

### Parameters
#### Options
- **extension** (array|string) - Required - Array of extensions or comma-delimited string of extensions against which to test.
- **case** (bool) - Optional - Whether extensions should match case sensitively; defaults to false (case-insensitive).
- **allowNonExistentFile** (bool) - Optional - Whether to allow validating a filename for a non-existent file; defaults to false.

### Methods
#### isValid(mixed $value) : bool
Validates the given file path, uploaded file array, or PSR-7 UploadedFileInterface instance.

### Usage Examples
```php
use Laminas\Validator\File\Extension;

$validator = new Extension([
    'extension' => ['php', 'exe'],
]);

$validator->isValid('./file.php'); // true
$validator->isValid('./file.PHP'); // true

$validator = new Extension([
    'extension' => 'php,exe',
    'case' => true,
]);

$validator->isValid('./file.php'); // true
$validator->isValid('./file.PHP'); // false
```

### Validating Arbitrary Filenames
```php
use Laminas\Validator\File\Extension;

$validator = new Extension([
    'extension' => 'gif,jpg,png',
    'allowNonExistentFile' => true,
]);

$validator->isValid('picture.jpg'); // true
$validator->isValid('something-else.txt'); // false
```

### Validating Uploaded Files
This validator accepts and validates 3 types of argument:
- A string that represents a path or a filename
- An array that represents an uploaded file as per PHP's $_FILES superglobal
- A PSR-7 UploadedFileInterface instance
```

--------------------------------

### Basic Usage of Laminas\Validator\File\NotExists

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/file/not-exists.md

Validates that a file does not exist in any of the specified directories. The 'directory' option accepts an array of directories or a comma-delimited string. Validation fails if the file exists in one or more of the given directories.

```php
use Laminas\Validator\File\NotExists;

// Only allow files that do not exist in any of the given directories
$validator = new NotExists([
    'directory' => ['/tmp', '/var/tmp'],
]);

if ($validator->isValid('some-file.txt')) {
    // File cannot be found in any of the directories provided
} else {
    // A file with the given name was found
}
```

--------------------------------

### Basic Step Validator Usage

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/step.md

Creates a Step validator with default options (baseValue 0, step 1) and checks if a value is a valid step value. The isValid method returns true for valid step values and false otherwise.

```php
$validator = new Laminas\Validator\Step();

if ($validator->isValid(1)) {
    // value is a valid step value
} else {
    // false
}
```

--------------------------------

### Basic ValidatorChain usage with StringLength and Regex

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validator-chains.md

Creates a validator chain and attaches validators to validate a username. Validators run in order added; both validators execute even if the first fails, and getMessages() returns messages from all failed validators.

```php
use Laminas\Validator\Regex;
use Laminas\Validator\StringLength;
use Laminas\Validator\ValidatorChain;

// Create a validator chain and add validators to it
$validatorChain = new ValidatorChain();
$validatorChain->attach(new StringLength(['min' => 6, 'max' => 12]));
$validatorChain->attach(new Regex(['pattern' => '/^[a-z0-9]+$/i']));

// Validate the username
if ($validatorChain->isValid($username)) {
    // username passed validation
} else {
    // username failed validation; print reasons
    foreach ($validatorChain->getMessages() as $message) {
        echo "$message\n";
    }
}
```

--------------------------------

### Restrict to SEPA Countries with allow_non_sepa

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/iban.md

Limits validation to SEPA countries by setting 'allow_non_sepa' to false. The example shows that an Austrian IBAN returns true, while a Bosnian IBAN returns false.

```php
$validator = new Laminas\Validator\Iban(['allow_non_sepa' => false]);

$validator->isValid('AT611904300234573201'); // true
$validator->isValid('BA391290079401028494'); // false
```

--------------------------------

### Replace LessThan with NumberComparison

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/migration/v2-to-v3.md

Shows the old LessThan validator configuration and its replacement using NumberComparison. The 'inclusive' option is renamed to 'inclusiveMax' in the new validator.

```php
$validator = new Laminas\Validator\LessThan([
    'max' => 10,
    'inclusive' => true,
]);
```

```php
$validator = new Laminas\Validator\NumberComparison([
    'max' => 10,
    'inclusiveMax' => true,
]);
```

--------------------------------

### Restricting acceptable JSON types with allow option

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/is-json-string.md

Uses the 'allow' option as a bit mask of ALLOW_* constants to restrict valid JSON types. The example excludes booleans, so 'true' is invalid.

```php
use Laminas\Validator\IsJsonString;

$validator = new IsJsonString([
    'allow' => IsJsonString::ALLOW_ALL ^ IsJsonString::ALLOW_BOOL,
]);

$validator->isValid('true'); // false
```

--------------------------------

### Restrict validation to ISBN-13 with type option

Source: https://github.com/laminas/laminas-validator/blob/3.19.x/docs/book/v3/validators/isbn.md

Creates a validator that only accepts ISBN-13 values by setting the 'type' option to Laminas\Validator\Isbn::ISBN13. Other valid types include AUTO (default) and ISBN10.

```php
use Laminas\Validator\Isbn;

$validator = new Isbn([ 'type' => Isbn::ISBN13]);

if ($validator->isValid($isbn)) {
    // this is a valid ISBN-13 value
} else {
    // this is an invalid ISBN-13 value
}
```
Tokens:
Raw