Laminas Inputfilter

https://github.com/laminas/laminas-inputfilter
Admin
The laminas-inputfilter component is used to filter and validate generic sets of input data, such as...
Tokens:89,220
Snippets:647
Trust Score:9.7
License:BSD-3-Clause
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install laminas-inputfilter via Composer

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/README.md

Use Composer to install the laminas-inputfilter component. This is the standard installation command for adding the library to your project.

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

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

### Basic Input usage example

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Shows how to create an Input, attach validators and filters, set a value, and call isValid and getValue. The example trims the value with StringTrim and validates with EmailAddress.

```php
use Laminas\InputFilter\Input;

$input = new Input('email');
$input->setRequired(true);
$input->getValidatorChain()->attachByName('EmailAddress');
$input->getFilterChain()->attachByName('StringTrim');

$input->setValue(' user@example.com ');
var_dump($input->isValid()); // true
echo $input->getValue();     // 'user@example.com'
```

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

### InputFilterProviderInterface and InputFilterAwareInterface Example

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/SupportingInterfaces.md

Example showing how to use provider interfaces in a model to create and attach an input filter.

```php
use Laminas\InputFilter\InputFilterProviderInterface;
use Laminas\InputFilter\InputFilterAwareTrait;
use Laminas\InputFilter\InputFilterAwareInterface;

class ContactMessage implements InputFilterProviderInterface, InputFilterAwareInterface
{
    use InputFilterAwareTrait;

    public function getInputFilterSpecification(): array
    {
        return [
            'email' => [
                'name'       => 'email',
                'required'   => true,
                'filters'    => [['name' => 'StringTrim']],
                'validators' => [['name' => 'EmailAddress']],
            ],
        ];
    }
}

use Laminas\InputFilter\Factory;

$message = new ContactMessage();
$filter  = (new Factory())->createInputFilter($message);   // InputFilterProviderInterface
$message->setInputFilter($filter);                         // InputFilterAwareInterface
var_dump($message->getInputFilter() === $filter);          // true

```

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

### Create InputFilter with Factory and configuration array

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Shows how to use Laminas\InputFilter\Factory to create an InputFilter from a configuration array. The example creates a required password input with NotEmpty and StringLength (min 8) validators, then validates $_POST data and outputs whether the form is valid.

```php
use Laminas\InputFilter\Factory;
use Laminas\Validator\NotEmpty;
use Laminas\Validator\StringLength;

$factory = new Factory();
$inputFilter = $factory->createInputFilter([
    'password' => [
        'name'       => 'password',
        'required'   => true,
        'validators' => [
            [
                'name' => NotEmpty::class,
            ],
            [
                'name' => StringLength::class,
                'options' => [
                    'min' => 8
                ],
            ],
        ],
    ],
]);

$inputFilter->setData($_POST);
echo $inputFilter->isValid() ? 'Valid form' : 'Invalid form';
```

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

### get(), has(), remove() method signatures

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/BaseInputFilter.md

Signatures for retrieving, checking, and removing inputs by name. get() throws for unknown names; all reject non-string/non-int names.

```php
public function get($name)     // src/BaseInputFilter.php:183 — @throws if unknown name
```

```php
public function has($name)     // src/BaseInputFilter.php:210
```

```php
public function remove($name)  // src/BaseInputFilter.php:229
```

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

### Create InputFilter with validators and nested InputFilter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Shows how to instantiate an InputFilter, add a single input with validators (NotEmpty, StringLength), and add another input filter containing a single input, merging both.

```php
use Laminas\InputFilter\InputFilter;
use Laminas\Validator\NotEmpty;
use Laminas\Validator\StringLength;

$filter = new InputFilter();

// Adding a single input
$filter->add([
    'name' => 'username',
    'required' => true,
    'validators' => [
        [
            'name' => NotEmpty::class,
        ],
        [
            'name' => StringLength::class,
            'options' => [
                'min' => 5
            ],
        ],
    ],
]);

// Adding another input filter what also contains a single input. Merging both.
$filter->add([
    'type' => 'Laminas\InputFilter\InputFilter',
    'password' => [
        'name' => 'password',
        'required' => true,
        'validators' => [
            [
                'name' => NotEmpty::class,
            ],
            [
                'name' => StringLength::class,
                'options' => [
                    'min' => 8
                ],
            ],
        ],
    ],
]);
```

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

### Declarative filter specification example

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilter.md

Shows the entry point for fully-declarative filters: passing an array specification to add() that defines an 'email' input with required flag, filters, and validators.

```php
$filter->add([
    'name'       => 'email',
    'required'   => true,
    'filters'    => [['name' => 'StringTrim']],
    'validators' => [['name' => 'EmailAddress']],
]);
```

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

### Create an Input with Factory::createInput

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Factory.md

Configures an input named 'qty' with filters and validators. The input is required, not allow_empty, and uses StringTrim and ToInt filters plus GreaterThan and Digits validators. The example dumps the input name to show 'qty'.

```php
use Laminas\InputFilter\Factory;

$factory = new Factory();

$input = $factory->createInput([
    'name'       => 'qty',
    'required'   => true,
    'allow_empty' => false,
    'filters'    => [
        ['name' => 'StringTrim'],
        ['name' => 'ToInt'],
    ],
    'validators' => [
        ['name' => 'GreaterThan', 'options' => ['min' => 1]],
        ['name' => 'Digits', 'break_chain_on_failure' => true],
    ],
]);
/** @var \Laminas\InputFilter\Input $input */
var_dump($input->getName());      // 'qty'
```

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

### get($name)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/BaseInputFilter.md

Retrieves an input by name. Throws an exception if the name is unknown.

```APIDOC
## get($name)

### Description
Retrieves an input by name. Throws an exception if the name is unknown.

### Method
GET

### Endpoint
`public function get($name)`

### Parameters
#### Path Parameters
- **$name** (array-key) - Required - Input name.

### Returns
- **InputInterface|InputFilterInterface** - The input instance associated with the given name.

### Throws
- **Exception\InvalidArgumentException** - When the name is unknown or not a string/int.

### Response Example
```php
$input
```
```

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

### get($name, ?array $options = null)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterPluginManager.md

Template-typed override of the service manager's get method. Retrieves a plugin by alias, FQCN, or normalized name, with optional creation options.

```APIDOC
## get($name, ?array $options = null)

### Description
Template-typed override of the service manager's `get` method. Retrieves a plugin by alias, FQCN, or normalized name, with optional creation options.

### Method
`get`

### Parameters
- **$name** (class-string|string) - Required - Alias, FQCN, or normalized name.
- **$options** (?array) - Optional - Default: `null` - Creation options passed to the factory.

### Returns
`InputInterface|InputFilterInterface` (psalm-typed by class-string).
```

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

### Imperative usage example with validation and values

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilter.md

Demonstrates imperative usage: creating an InputFilter, adding inputs via specs and a FileInput instance, setting data, validating, and retrieving messages or filtered values. Exits with code 1 on invalid data.

```php
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\FileInput;

$filter = new InputFilter();
$filter->add(['name' => 'username', 'required' => true, 'validators' => [['name' => 'StringLength', 'options' => ['min' => 3]]]]);
$filter->add(new FileInput('doc'));
$filter->add(['name' => 'optional', 'required' => false]);
$filter->setData(['username' => 'ab', 'doc' => $_FILES['doc'] ?? null]);

if (! $filter->isValid()) {
    $errors = $filter->getMessages(); // per-input validator messages
    exit(1);
}
$values = $filter->getValues();      // filtered values, keyed by name
```

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

### Provider interfaces in a model

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/SupportingInterfaces.md

Example showing a model class implementing InputFilterProviderInterface and InputFilterAwareInterface, then creating an input filter from it via Factory and attaching it to the model.

```php
use Laminas\InputFilter\InputFilterProviderInterface;
use Laminas\InputFilter\InputFilterAwareTrait;
use Laminas\InputFilter\InputFilterAwareInterface;

class ContactMessage implements InputFilterProviderInterface, InputFilterAwareInterface
{
    use InputFilterAwareTrait;

    public function getInputFilterSpecification(): array
    {
        return [
            'email' => [
                'name'       => 'email',
                'required'   => true,
                'filters'    => [['name' => 'StringTrim']],
                'validators' => [['name' => 'EmailAddress']],
            ],
        ];
    }
}

use Laminas\InputFilter\Factory;

$message = new ContactMessage();
$filter  = (new Factory())->createInputFilter($message);   // InputFilterProviderInterface
$message->setInputFilter($filter);                         // InputFilterAwareInterface
var_dump($message->getInputFilter() === $filter);          // true
```

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

### Valid data sets for optional project filter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/optional-input-filters.md

Four JSON examples showing valid data sets: profile-only, null project, empty project, and a valid project with required fields. These illustrate that the optional project filter accepts missing, null, or empty project data while still validating when provided.

```json
{
  "email": "user@example.com",
  "title": "Software Developer"
}
```

```json
{
  "email": "user@example.com",
  "title": "Software Developer",
  "project": null
}
```

```json
{
  "email": "user@example.com",
  "title": "Software Developer",
  "project": {}
}
```

```json
{
  "email": "user@example.com",
  "title": "Software Developer",
  "project": {
    "project_name": "laminas-inputfilter",
    "url": "https://github.com/laminas-inputfilter"
  }
}
```

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

### Catch all Laminas InputFilter exceptions via ExceptionInterface

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/errors.md

All library exceptions implement ExceptionInterface, so catching it covers everything thrown by the component. The example shows catching RuntimeException and InvalidArgumentException separately, plus a broad catch for consumer code and plugin manager validation.

```php
use Laminas\InputFilter\Exception\ExceptionInterface;
use Laminas\InputFilter\Exception\InvalidArgumentException;
use Laminas\InputFilter\Exception\RuntimeException;

try {
    $filter->setData('nope');                    // InvalidArgumentException (#9)
    $filter->isValid();                          // RuntimeException (#1) if no data was set
} catch (RuntimeException $e) {
    // e.g. "no data present to validate!" — call setData() first
} catch (InvalidArgumentException $e) {
    // e.g. "setData() expects an array or Traversable argument; received string"
}

// Broad catch for consumer code:
try {
    $collection->setInputFilter(new \ArrayObject());  // RuntimeException (#4)
} catch (ExceptionInterface $e) {
    echo $e->getMessage();
}

// Plugin manager validation:
use Laminas\InputFilter\InputFilterPluginManager;
use Laminas\ServiceManager\Exception\InvalidServiceException;

try {
    $manager->get('SomeInvalidPlugin');
} catch (InvalidServiceException $e) {
    // "Plugin of type ... is invalid; must implement ..."
}
```

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

### Filter data without validation using getFilterChain

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Demonstrates filtering input data without validation by attaching filters to the filter chain of an Input instance. The example trims and removes non-alpha characters from the 'foo' input. getValue() returns the filtered value ('Bar'), while getRawValue() returns the original value (' Bar3 ').

```php
use Laminas\InputFilter\Input;
use Laminas\InputFilter\InputFilter;

$input = new Input('foo');
$input->getFilterChain()
      ->attachByName('stringtrim')
      ->attachByName('alpha');

$inputFilter = new InputFilter();
$inputFilter->add($input);
$inputFilter->setData([
    'foo' => ' Bar3 ',
]);

echo "Before:\n";
echo $inputFilter->getRawValue('foo') . "\n"; // the output is ' Bar3 '
echo "After:\n";
echo $inputFilter->getValue('foo') . "\n";    // the output is 'Bar'
```

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

### Example: optional filter skipping validation

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/OptionalInputFilter.md

Shows that with empty data, validation is skipped and getValues returns null; with non-empty data, normal validation runs.

```php
use Laminas\InputFilter\OptionalInputFilter;

$filter = new OptionalInputFilter();
$filter->add(['name' => 'search', 'required' => true, 'validators' => [['name' => 'Alpha']]]);

// No data provided — validation is skipped entirely:
$filter->setData([]);
var_dump($filter->isValid());   // true
var_dump($filter->getValues()); // null — not [] — so a hydrator won't be triggered

// Non-empty data runs the normal pipeline:
$filter->setData(['search' => 'hello']);
var_dump($filter->isValid());   // true
var_dump($filter->getValues()); // ['search' => 'hello']
```

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

### Create main InputFilter and compose project sub-filter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/optional-input-filters.md

Builds the primary profile filter with optional 'title' and required 'email' (EmailAddress validator), then composes the previously created project filter as a sub-filter named 'project'. This setup allows the project data to be optional while still validating it when provided.

```php
$profileFilter = new InputFilter();
$profileFilter->add([
    'name' => 'title',
    'required' => false,
]);
$profileFilter->add([
    'name' => 'email',
    'required' => true,
    'validators' => [
        ['type' => 'EmailAddress'],
    ],
]);

// And, finally, compose our project sub-filter:
$profileFilter->add($projectFilter, 'project');
```

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

### get

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterInterface.md

Retrieves an input or input filter by name.

```APIDOC
## get

### Description
Retrieves an input or input filter by name.

### Method
get

### Signature
```php
public function get($name);
```

### Parameters
- **$name** (array-key) - Required - The name of the input to retrieve.

### Return Value
- **InputInterface|InputFilterInterface** - The input or input filter with the given name.
```

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

### Example: nested as an optional sub-filter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/OptionalInputFilter.md

Demonstrates using OptionalInputFilter as a sub-filter within a parent InputFilter; empty payload yields ['address' => null].

```php
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\OptionalInputFilter;
use Laminas\InputFilter\Input;

$address = new OptionalInputFilter();
$address->add(new Input('street'));
$address->add(['name' => 'zip', 'validators' => [['name' => 'Digits']]]);

$form = new InputFilter();
$form->add($address, 'address');

$form->setData([]);                    // whole payload optional
var_dump($form->isValid());            // true
var_dump($form->getValues());          // ['address' => null]
```

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

### Create AlbumController with input filter plugin manager injection

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/application-integration/usage-in-a-laminas-mvc-application.md

Defines a controller class in module/Album/Controller/AlbumController.php. The constructor injects the InputFilterPluginManager, which is used to retrieve the QueryInputFilter, set query data, validate, and get filtered values. The plugin manager ensures filter and validator plugin managers are injected and calls init() after instantiation.

```php
namespace Album\Controller;

use Album\InputFilter\QueryInputFilter;
use Laminas\InputFilter\InputFilterPluginManager;
use Laminas\Mvc\Controller\AbstractActionController;

use function assert;

final class AlbumController extends AbstractActionController
{
    public function __construct(
        public readonly InputFilterPluginManager $inputFilterPluginManager
    ) {}
    
    public function indexAction()
    {
        $inputFilter = $this->inputFilterPluginManager->get(QueryInputFilter::class);
        assert($inputFilter instanceof QueryInputFilter);
    
        $inputFilter->setData($this->getRequest()->getQuery());
        $inputFilter->isValid();
        $filteredParams = $inputFilter->getValues();
        
        // …
    }
}
```

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

### Merge InputFilters in a class using getInputFilter and setInputFilter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Illustrates using the merge() method on an InputFilterInterface to combine multiple filters. Defines NameInputFilter and EmailInputFilter classes, then merges them into a new InputFilter within a SimplePerson class. When isValid() is called, all merged filters run against the object.

```php
use Laminas\InputFilter\InputFilter;

/**
 * Filter to ensure a name property is set and > 8 characters
 */
class NameInputFilter extends InputFilter
{
    /** Filter body goes here **/
}

/**
 * Filter to ensure an email property is set and > 8 characters and is valid
 */
class EmailInputFilter extends InputFilter
{
    /** Filter body goes here **/
}

class SimplePerson
{
    /** Member variables omitted for brevity **/

    /** @var InputFilter */
    protected $inputFilter;

    /**
     * Retrieve input filter
     *
     * @return InputFilter
     */
    public function getInputFilter()
    {
        if (! $this->inputFilter) {
            // Create a new input filter
            $this->inputFilter = new InputFilter();

            // Merge our inputFilter in for the email property
            $this->inputFilter->merge(new EmailInputFilter());

            // Merge our inputFilter in for the name property
            $this->inputFilter->merge(new NameInputFilter());
        }

        return $this->inputFilter;
    }

    /**
     * Set input filter
     *
     * @param  InputFilterInterface $inputFilter
     * @return SimplePerson
     */
    public function setInputFilter(InputFilterInterface $inputFilter)
    {
        $this->inputFilter = $inputFilter;

        return $this;
    }
}
```

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

### Validate POST data with InputFilter and Input

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Shows how to validate email and password inputs from $_POST using InputFilter, Input, and validator chains. The email must be a valid address and the password must be at least 8 characters. If validation fails, getInvalidInput() returns the invalid inputs and their messages.

```php
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\Input;
use Laminas\Validator;

$email = new Input('email');
$email->getValidatorChain()
      ->attach(new Validator\EmailAddress());

$password = new Input('password');
$password->getValidatorChain()
         ->attach(new Validator\StringLength(8));

$inputFilter = new InputFilter();
$inputFilter->add($email);
$inputFilter->add($password);
$inputFilter->setData($_POST);

if ($inputFilter->isValid()) {
    echo "The form is valid\n";
} else {
    echo "The form is not valid\n";
    foreach ($inputFilter->getInvalidInput() as $error) {
        print_r($error->getMessages());
    }
}
```

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

### Factory::clearDefaultFilterChain

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Factory.md

Drops the default filter chain so new inputs get none.

```APIDOC
## Factory::clearDefaultFilterChain

### Description
Drops the default filter chain so new inputs get none.

### Method
clearDefaultFilterChain

### Signature
public function clearDefaultFilterChain()

### Returns
- `void`
```

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

### Set validation group with setValidationGroup

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/intro.md

Shows two ways to specify a validation group, a subset of data to validate: as individual parameters or as an array of input names. Use this to limit which inputs are validated.

```php
// As individual parameters
$inputFilter->setValidationGroup('email', 'password');

// or as an array of names
$inputFilter->setValidationGroup(['email', 'password']);
```

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

### Declarative input filter configuration (config/autoload/input-filter.global.php)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/configuration.md

Defines a complete input filter configuration using the 'input_filters' and 'input_filter_specs' keys. Registers a custom factory for 'MyApp\Filter\Custom' and specifies the 'MyApp\Filter\Signup' input filter with fields for username, password, and a roles collection. The password field uses break_on_failure and validators for minimum length and digit requirement; the roles collection is optional with a required_message.

```php
// config/autoload/input-filter.global.php
return [
    'input_filters' => [
        'factories' => [
            'MyApp\Filter\Custom' => 'MyApp\Filter\CustomFactory',
        ],
    ],
    'input_filter_specs' => [
        'MyApp\Filter\Signup' => [
            'type' => 'Laminas\InputFilter\InputFilter',
            'username' => [
                'name'     => 'username',
                'required' => true,
                'filters'  => [['name' => 'StringTrim']],
            ],
            'password' => [
                'name'           => 'password',
                'required'       => true,
                'break_on_failure' => true,
                'validators'     => [
                    ['name' => 'StringLength', 'options' => ['min' => 8]],
                    ['name' => 'Regex', 'options' => ['pattern' => '/[0-9]/']],
                ],
            ],
            'roles' => [
                'type'           => 'collection',
                'required'       => false,
                'count'          => 1,
                'required_message' => 'At least one role must be provided',
                'input_filter'   => [
                    'role' => ['name' => 'role', 'required' => true],
                ],
            ],
        ],
    ],
];
```

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

### init()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/BaseInputFilter.md

No-op hook automatically called when creating element with factory. Subclasses override it to add inputs after instantiation.

```APIDOC
## init()

### Description
No-op hook, automatically called when creating element with factory. Subclasses override it to add inputs after instantiation.

### Method
init

### Signature
public function init()

### Returns
void
```

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

### init method signature

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/BaseInputFilter.md

No-op hook automatically called when creating element with factory. Subclasses override it to add inputs after instantiation.

```php
public function init() // src/BaseInputFilter.php:61
```

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

### setIsRequired / getIsRequired

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/CollectionInputFilter.md

Sets or gets whether an empty collection fails validation. The setter returns the instance for chaining, and the getter returns a boolean.

```APIDOC
## setIsRequired / getIsRequired

### Description
Sets or gets whether an empty collection fails validation. The setter returns the instance for chaining, and the getter returns a boolean.

### Method
- `setIsRequired($isRequired)`
- `getIsRequired()`

### Parameters
#### `setIsRequired`
- **$isRequired** (bool) - Required - Whether an empty collection fails validation. Default: `false`.

### Returns
- `setIsRequired()` returns `$this`.
- `getIsRequired()` returns `bool`.

```

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

### Module::init

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/ServiceIntegration.md

Initializes the module by registering the InputFilterManager with the ServiceListener. This method is called during module bootstrap.

```APIDOC
## Module::init

### Description
Registers the InputFilterManager with the ServiceListener for the `input_filters` config key and the `InputFilterProviderInterface` feature.

### Method
`init($moduleManager)`

### Parameters
- **$moduleManager** (`Laminas\ModuleManager\ModuleManager`) - Required - Module manager during bootstrap.

### Returns
Void

### Example
```php
$module->init($moduleManager);
```
```

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

### Register input filter and handler in ConfigProvider

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/application-integration/usage-in-a-mezzio-application.md

Extends the module's configuration provider to register the input filter and the request handler. Adds an 'input_filters' key and a factory for QueryInputFilter, plus a factory for ListHandler in dependencies.

```php
namespace Album;

class ConfigProvider
{
    public function __invoke() : array
    {
        return [
            'dependencies'  => $this->getDependencies(),
            'input_filters' => $this->getInputFilters(), // <-- Add this line
        ];
    }
    
    public function getDependencies() : array
    {
        return [
            'factories' => [
                Handler\ListHandler::class => Handler\ListHandlerFactory::class, // <-- Add this line
                // …
            ],
        ];
    }

    // Add the following method
    public function getInputFilters() : array
    {
        return [
            'factories' => [
                InputFilter\QueryInputFilter::class => InvokableFactory::class,
            ],
        ];
    }
    
    // …
}
```

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

### Input::__construct

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Constructor for the Input class. Initializes a new input instance with an optional name used to identify it within an input filter.

```APIDOC
## Input::__construct

### Description
Constructor for the Input class. Initializes a new input instance with an optional name used to identify it within an input filter.

### Method
`__construct`

### Signature
```php
public function __construct(protected $name = null)
```

### Parameters
- **$name** (`?string`) - Optional - Name used to identify this input inside an input filter. Defaults to `null`.

### Returns
No return value (constructor).
```

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

### Factory::createInput() / Factory::createInputFilter()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/configuration.md

Consumed by Factory::createInput() and Factory::createInputFilter() to build input and input filter instances from specification arrays. The specification keys define how inputs, input filters, and collections are configured.

```APIDOC
## Factory::createInput() / Factory::createInputFilter()

### Description
Consumed by `Factory::createInput()` and `Factory::createInputFilter()` to build input and input filter instances from specification arrays. The specification keys define how inputs, input filters, and collections are configured.

### Method
Factory method (PHP)

### Endpoint
`Factory::createInput()` / `Factory::createInputFilter()`

### Parameters
#### Input-level keys (`InputSpecification`)
- **type** (`string|class-string`) - Optional - Concrete class or plugin-manager alias (`Input`, `ArrayInput`, `FileInput`, or any `InputInterface` class). Inputs resolving to an `InputFilterInterface` are re-routed to `createInputFilter()`.
- **name** (`array-key`) - Optional - `Input::setName()`.
- **required** (`bool`) - Optional - `Input::setRequired()`. Without `required`, `allow_empty: true` flips required to `false`.
- **allow_empty** (`bool`) - Optional - `Input::setAllowEmpty()`.
- **continue_if_empty** (`bool`) - Optional - `Input::setContinueIfEmpty()`; `Exception\RuntimeException` unless the input is an `Input`.
- **error_message** (`string|null`) - Optional - `Input::setErrorMessage()`.
- **fallback_value** (`mixed|null`) - Optional - `Input::setFallbackValue()`; `Exception\RuntimeException` unless the input is an `Input`.
- **break_on_failure** (`bool`) - Optional - `Input::setBreakOnFailure()`; aborts `BaseInputFilter::validateInputs()` on failure.
- **filters** (`FilterChain|iterable`) - Optional - Each entry: `FilterInterface`/callable instance, or `['name' => ..., 'priority' => int, 'options' => [...]]`. Non-chain non-iterable → `Exception\RuntimeException`.
- **validators** (`ValidatorChain|iterable`) - Optional - Each entry: `ValidatorInterface` instance, or `['name' => ..., 'priority' => int, 'break_chain_on_failure' => bool, 'options' => [...]]`. Non-chain non-iterable → `Exception\RuntimeException`.
- **(any other key)** (`mixed`) - Optional - Ignored.

#### Input-filter-level keys (`InputFilterSpecification`)
- **type** (`string|class-string<InputFilterInterface>`) - Optional - Resolved through `InputFilterPluginManager` (aliases: `InputFilter`, `collection` → `CollectionInputFilter`, `optionalinputfilter` → `OptionalInputFilter`, legacy `Zend\...` aliases).
- **<name>** (`InputSpecification|InputInterface|InputFilterInterface`) - Required - Named child; `null` values skipped; instances attached directly; specs via `createInput()`. Nested integer-keyed specs with `type` (an InputFilter) + `name` are re-keyed to `name`.

#### Collection-level keys (`CollectionSpecification`, active when `type` resolves to `CollectionInputFilter`)
- **type** (`string|class-string`) - Optional - Must resolve to `CollectionInputFilter` (e.g. `collection` or the FQCN).
- **input_filter** (`InputFilterSpecification|InputFilterInterface`) - Optional - `CollectionInputFilter::setInputFilter()`.
- **count** (`int`) - Optional - `CollectionInputFilter::setCount()`; rows `< count` → invalid.
- **required** (`bool`) - Optional - `CollectionInputFilter::setIsRequired()`; empty collection → invalid when `true`.
- **required_message** (`string`) - Optional - `CollectionInputFilter::getNotEmptyValidator()->setMessage(...)`.

### Response
Returns an `InputInterface` or `InputFilterInterface` instance as configured by the specification.
```

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

### Create QueryInputFilter class

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/application-integration/usage-in-a-mezzio-application.md

Defines an input filter class extending Laminas\InputFilter\InputFilter with a page field, allowing empty values, validating with IsInt, filtering with ToInt, and providing a fallback value of 1. The init() method is called by the InputFilterPluginManager after instantiation.

```php
namespace Album\InputFilter;

use Laminas\Filter\ToInt;
use Laminas\I18n\Validator\IsInt;
use Laminas\InputFilter\InputFilter;

class QueryInputFilter extends InputFilter
{
    public function init()
    {
        // Page
        $this->add(
            [
                'name'              => 'page',
                'allow_empty'       => true,
                'validators'        => [
                    [
                        'name' => IsInt::class,                        
                    ],                    
                ],
                'filters'           => [
                    [
                        'name' => ToInt::class,
                    ],
                ],
                'fallback_value'    => 1,
            ]
        );
    
        // …
    }
}
```

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

### Create ListHandlerFactory

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/application-integration/usage-in-a-mezzio-application.md

Factory that retrieves the QueryInputFilter from the InputFilterPluginManager and passes it along with the template renderer to the ListHandler. Using the plugin manager ensures filter and validator plugin managers are injected and init() is called after instantiation.

```php
namespace Album\Handler;

use Album\InputFilter\QueryInputFilter;
use Psr\Container\ContainerInterface;
use Laminas\InputFilter\InputFilterPluginManager;

class ListHandlerFactory
{
    public function __invoke(ContainerInterface $container)
    {
        /** @var InputFilterPluginManager $pluginManager */
        $pluginManager = $container->get(InputFilterPluginManager::class);
        $inputFilter   = $pluginManager->get(QueryInputFilter::class);

        return new ListHandler(
            $inputFilter,
            $container->get(TemplateRendererInterface::class)
        );
    }
}
```

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

### setCount / getCount

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/CollectionInputFilter.md

Sets or gets the expected row count for the collection. The setter clamps the count to a non-negative integer and returns the instance; the getter returns the configured count, the data count if data is set and no count was configured, or 0.

```APIDOC
## setCount / getCount

### Description
Sets or gets the expected row count for the collection. The setter clamps the count to a non-negative integer and returns the instance; the getter returns the configured count, the data count if data is set and no count was configured, or 0.

### Method
- `setCount($count)`
- `getCount()`

### Parameters
#### `setCount`
- **$count** (int) - Required - Expected row count for the collection.

### Returns
- `setCount()` returns `CollectionInputFilter`.
- `getCount()` returns `int`.

### Validation Semantics
- A configured `$count` acts as an exact/expected row count: the collection is invalid when `count($this->data) < $this->getCount()`.
- A "required/empty" message is produced when `getCount() < 1 && isRequired`.

```

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

### ConfigProvider::__invoke method signature

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/ServiceIntegration.md

Returns the component's dependency and input filter configuration arrays. The return value is an array with keys 'dependencies' and 'input_filters'.

```php
/**
 * Return configuration for this component.
 *
 * @return array{
 *     dependencies: ServiceManagerConfigurationType,
 *     input_filters: ServiceManagerConfigurationType,
 * }
 */
public function __invoke() // src/ConfigProvider.php:23
```

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

### Basic FileInput usage with $_POST and $_FILES

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/file-input.md

Shows how to use FileInput with a standard Request, merging $_POST and $_FILES data. Validators run before filters for FileInput, and filters execute only when getValues() is called.

```php
use Laminas\Http\PhpEnvironment\Request;
use Laminas\Filter;
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\Input;
use Laminas\InputFilter\FileInput;
use Laminas\Validator;

// Description text input
$description = new Input('description'); // Standard Input type

// Filters are run first w/ Input
$description
    ->getFilterChain()
    ->attach(new Filter\StringTrim());

// Validators are run second w/ Input
$description
    ->getValidatorChain()
    ->attach(new Validator\StringLength(['max' => 140]));

// File upload input
$file = new FileInput('file'); // Special File Input type

// Validators are run first w/ FileInput
$file
    ->getValidatorChain()
    ->attach(new Validator\File\UploadFile());

// Filters are run second w/ FileInput
$file
    ->getFilterChain()
    ->attach(new Filter\File\RenameUpload([
         'target'    => './data/tmpuploads/file',
         'randomize' => true,
    ]));

// Merge $_POST and $_FILES data together
$request  = new Request();
$postData = array_merge_recursive(
    $request->getPost()->toArray(),
    $request->getFiles()->toArray()
);

$inputFilter = new InputFilter();
$inputFilter
    ->add($description)
    ->add($file)
    ->setData($postData);

if ($inputFilter->isValid()) {           // FileInput validators are run, but not the filters...
    echo "The form is valid\n";
    $data = $inputFilter->getValues();   // This is when the FileInput filters are run.
} else {
    echo "The form is not valid\n";
    foreach ($inputFilter->getInvalidInput() as $error) {
        print_r ($error->getMessages());
    }
}
```

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

### Catch InvalidServiceException from InputFilterPluginManager::get()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterPluginManager.md

Shows how to trigger and catch an InvalidServiceException when the plugin manager returns an invalid plugin. Register a factory that returns a plain stdClass object, then call get() to see the exception message: 'Plugin of type stdClass is invalid; must implement Laminas\InputFilter\InputFilterInterface or Laminas\InputFilter\InputInterface'.

```php
use Laminas\InputFilter\InputFilterPluginManager;
use Laminas\ServiceManager\Exception\InvalidServiceException;

$manager = new InputFilterPluginManager();
// Register a factory returning an invalid plugin (e.g. a plain object):
$manager->setFactory(\stdClass::class, static fn () => new \stdClass());

try {
    $manager->get(\stdClass::class);
} catch (InvalidServiceException $e) {
    echo $e->getMessage();
    // 'Plugin of type stdClass is invalid; must implement Laminas\InputFilter\InputFilterInterface or Laminas\InputFilter\InputInterface'
}
```

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

### Input constructor

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Constructor for the Input class, accepts an optional name parameter.

```php
public function __construct(protected $name = null) // src/Input.php:61
```

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

### getName()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Returns the input name.

```APIDOC
## getName()

### Description
Returns the input name.

### Method
`getName`

### Returns
`?string`
```

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

### createService(ServiceLocatorInterface $container, $name = null, $requestedName = null)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterPluginManager.md

v2 compatibility shim that delegates to __invoke() to create the plugin manager.

```APIDOC
## `createService(ServiceLocatorInterface $container, $name = null, $requestedName = null)`

### Description
v2 compatibility shim that delegates to `__invoke()` to create the plugin manager.

### Method
`createService`

### Signature
`public function createService(ServiceLocatorInterface $container, $name = null, $requestedName = null)`

### Parameters
- **$container** (ServiceLocatorInterface) - Required - The service locator used to build the plugin manager.
- **$name** (mixed) - Optional - Service name (unused in implementation).
- **$requestedName** (mixed) - Optional - Requested service name (unused in implementation).

### Returns
- **InputFilterPluginManager** - The created plugin manager instance.
```

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

### Using InputFilterInterface type with InputFilter

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterInterface.md

Shows how to type-hint against the InputFilterInterface while instantiating the concrete InputFilter. Demonstrates adding a non-required field, setting data, validating, restricting validation to a single field with setValidationGroup('q'), resetting the group with InputFilterInterface::VALIDATE_ALL, and using Countable via count($filter).

```php
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\InputFilterInterface;

/** @var InputFilterInterface $filter */
$filter = new InputFilter();
$filter->add(['name' => 'q', 'required' => false]);

$filter->setData(['q' => 'search term']);
var_dump($filter->isValid());             // bool
$filter->setValidationGroup('q');         // validate only 'q'
$filter->setValidationGroup(InputFilterInterface::VALIDATE_ALL); // reset group
echo count($filter);                      // 1 (Countable)

```

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

### Retrieve and use input filter in Mezzio handler/factory

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/ServiceIntegration.md

Shows how to fetch the configured input filter from the container in a Mezzio handler or factory, set data from the request body, and validate it. On failure, return a 422 response with the filter's messages.

```php
// In a handler/factory, Mezzio (ConfigProvider merges 'dependencies'):
/** @var \Psr\Container\ContainerInterface $container */
$filter = $container->get('Application\InputFilter\ContactForm'); // via InputFilterAbstractServiceFactory
$filter->setData($request->getParsedBody());
if (! $filter->isValid()) {
    // 422 with $filter->getMessages()
}
```

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

### continueIfEmpty()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Returns true if validators run on empty values.

```APIDOC
## continueIfEmpty()

### Description
Returns `true` if validators run on empty values.

### Method
`continueIfEmpty`

### Returns
`bool`
```

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

### add() method signature

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/BaseInputFilter.md

Signature for adding an input or input filter. Accepts only instances; unnamed InputInterface children require a name parameter. Throws InvalidArgumentException for invalid types, missing names, or empty-string names.

```php
public function add($input, $name = null) // src/BaseInputFilter.php:87
```

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

### Mixing instances and specs, then replacing an input

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilter.md

Shows mixing Input instances and array specs, then using replace() to swap an input. BaseInputFilter::replace() throws Exception\InvalidArgumentException if the name doesn't exist.

```php
use Laminas\InputFilter\InputFilter;
use Laminas\InputFilter\Input;

$filter = new InputFilter();
$filter->add(new Input('a'), 'a');       // instance + explicit name
$filter->add(['name' => 'b', 'required' => false]); // spec, default type Input

$replacement = new Input('a');
$replacement->setRequired(false);
$filter->replace($replacement, 'a');     // RemoveException-free swap; BaseInputFilter::replace()
                                         // throws Exception\InvalidArgumentException if 'a' didn't exist
```

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

### getFactory method signature

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilter.md

Returns the attached factory, lazy-initialized as new Factory() when none was set.

```php
public function getFactory() // src/InputFilter.php:39
```

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

### Module::init method signature

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/ServiceIntegration.md

Registers InputFilterManager with the ServiceListener for the 'input_filters' config key and the InputFilterProviderInterface feature. Requires a Laminas\ModuleManager\ModuleManager instance.

```php
public function init($moduleManager) // src/Module.php:41
```

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

### add

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterInterface.md

Adds an input or input filter to the collection. Must handle at least one of the specified input types and throw an exception for unsupported types.

```APIDOC
## add

### Description
Adds an input or input filter to the collection. Must handle at least one of the specified input types and throw an exception for unsupported types.

### Method
add

### Signature
```php
public function add($input, $name = null);
```

### Parameters
- **$input** (InputInterface|InputFilterInterface|InputSpecification|Traversable) - Required - The input to add.
- **$name** (null|array-key) - Optional - Name used to retrieve this input.

### Return Value
- **InputFilterInterface** - Returns the instance for chaining.

### Exceptions
- **Exception\InvalidArgumentException** - If unable to handle the input type.
```

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

### allowEmpty()

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Returns true if empty values are accepted for the input.

```APIDOC
## allowEmpty()

### Description
Returns `true` if empty values are accepted.

### Method
`allowEmpty`

### Returns
`bool`
```

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

### Create Input Filter as Separate Class

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/docs/book/v2/cookbook/input-filter-in-forms.md

Defines an input filter class extending Laminas\InputFilter\InputFilter. The init() method adds inputs with filters (StripTags, StringTrim) and validators (StringLength with min/max). This class is later referenced by a form.

```php
namespace Album\InputFilter;

use Laminas\Filter\StringTrim;
use Laminas\Filter\StripTags;
use Laminas\Validator\StringLength;
use Laminas\InputFilter\InputFilter;

final class AlbumInputFilter extends InputFilter
{
    public function init(): void
    {
        // Add inputs
        $this->add(
            [
                'name'    => 'title',
                'filters' => [
                    ['name' => StripTags::class],
                    ['name' => StringTrim::class],
                ],
                'validators' => [
                    [
                        'name'    => StringLength::class,
                        'options' => [
                            'min' => 1,
                            'max' => 100,
                        ],
                    ],
                ],
            ]
        );

        // …
    }
}
```

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

### setCreationOptions(array $options)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/InputFilterPluginManager.md

v2 creation-options storage method. Stores the provided options for later use.

```APIDOC
## `setCreationOptions(array $options)`

### Description
v2 creation-options storage method. Stores the provided options for later use.

### Method
`setCreationOptions`

### Signature
`public function setCreationOptions(array $options)`

### Parameters
- **$options** (array) - Required - Creation options to store.

### Returns
- **void** - No return value.
```

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

### Input fallback value and continue_if_empty error handling

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/Input.md

Shows how to use Laminas\InputFilter\Input with setFallbackValue() to substitute a value on validation failure, and setContinueIfEmpty(true) to run validators on empty values. When fallback is applied, getMessages() returns an empty array and getValue() returns the fallback. With continue_if_empty, isValid() returns false for an empty value because NotEmpty is not injected, but a manually attached validator still runs.

```php
use Laminas\InputFilter\Input;

$input = new Input('age');
$input->setRequired(true);
$input->setFallbackValue(0);             // substitute on failure
$input->getValidatorChain()->attachByName('Digits');

$input->setValue('abc');
if (! $input->isValid()) {
    // fallback was applied, so messages are empty:
    var_dump($input->getMessages());     // []
    echo $input->getValue();             // 0
}

// Example with continue_if_empty + reporting real messages:
$input2 = new Input('note');
$input2->setAllowEmpty(false);
$input2->setContinueIfEmpty(true);       // empty value still runs validators
$input2->setValue('');
var_dump($input2->isValid());            // false — NotEmpty is *not* injected,
                                         // but a manually attached validator runs
```

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

### merge(InputInterface $input)

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/FileInput.md

Merges another input into this one, copying the auto-prepend flag in addition to the parent Input::merge() behavior.

```APIDOC
## merge(InputInterface $input)

### Description
Merges another input into this one, copying the auto-prepend flag in addition to the parent Input::merge() behavior.

### Method
merge

### Parameters
- **$input** (InputInterface) - Required - The input to merge.

### Returns
$this
```

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

### isEmpty private helper method

Source: https://github.com/laminas/laminas-inputfilter/blob/2.36.x/_autodocs/api-reference/OptionalInputFilter.md

Private helper that converts Traversable data to an array and returns true when the result is empty or null.

```php
private function isEmpty(iterable|null $data): bool // src/OptionalInputFilter.php:65
```
Tokens:
Raw