Download the PHP package nette/schema without Composer

On this page you can find all versions of the php package nette/schema. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.


After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package schema

Nette Schema

Downloads this Month Tests Coverage Status Latest Stable Version License


A practical library for validation and normalization of data structures against a given schema with a smart & easy-to-understand API.

Documentation can be found on the website.


It requires PHP version 8.0 and supports PHP up to 8.2.

Support Me

Do you like Nette Schema? Are you looking forward to the new features?

Buy me a coffee

Thank you!

Basic Usage

In variable $schema we have a validation schema (what exactly this means and how to create it we will say later) and in variable $data we have a data structure that we want to validate and normalize. This can be, for example, data sent by the user through an API, configuration file, etc.

The task is handled by the Nette\Schema\Processor class, which processes the input and either returns normalized data or throws an Nette\Schema\ValidationException exception on error.

Method $e->getMessages() returns array of all message strings and $e->getMessageObjects() return all messages as Nette\Schema\Message objects.

Defining Schema

And now let's create a schema. The class Nette\Schema\Expect is used to define it, we actually define expectations of what the data should look like. Let's say that the input data must be a structure (e.g. an array) containing elements processRefund of type bool and refundAmount of type int.

We believe that the schema definition looks clear, even if you see it for the very first time.

Lets send the following data for validation:

The output, i.e. the value $normalized, is the object stdClass. If we want the output to be an array, we add a cast to schema Expect::structure([...])->castTo('array').

All elements of the structure are optional and have a default value null. Example:

The fact that the default value is null does not mean that it would be accepted in the input data 'processRefund' => null. No, the input must be boolean, i.e. only true or false. We would have to explicitly allow null via Expect::bool()->nullable().

An item can be made mandatory using Expect::bool()->required(). We change the default value to false using Expect::bool()->default(false) or shortly using Expect::bool(false).

And what if we wanted to accept 1 and 0 besides booleans? Then we list the allowed values, which we will also normalize to boolean:

Now you know the basics of how the schema is defined and how the individual elements of the structure behave. We will now show what all the other elements can be used in defining a schema.

Data Types: type()

All standard PHP data types can be listed in the schema:

And then all types supported by the Validators via Expect::type('scalar') or abbreviated Expect::scalar(). Also class or interface names are accepted, e.g. Expect::type('AddressEntity').

You can also use union notation:

The default value is always null except for array and list, where it is an empty array. (A list is an array indexed in ascending order of numeric keys from zero, that is, a non-associative array).

Array of Values: arrayOf() listOf()

The array is too general structure, it is more useful to specify exactly what elements it can contain. For example, an array whose elements can only be strings:

The list is an indexed array:

The parameter can also be a schema, so we can write:

The default value is an empty array. If you specify default value and call mergeDefaults(), it will be merged with the passed data.

Enumeration: anyOf()

anyOf() is a set of values ​​or schemas that a value can be. Here's how to write an array of elements that can be either 'a', true, or null:

The enumeration elements can also be schemas:

The default value is null.


Structures are objects with defined keys. Each of these key => value pairs is referred to as a "property":

Structures accept arrays and objects and return objects stdClass (unless you change it with castTo('array'), etc.).

By default, all properties are optional and have a default value of null. You can define mandatory properties using required():

Although null is the default value of the optional property, it is not allowed in the input data (the value must be a string). Properties accepting null are defined using nullable():

By default, there can be no extra items in the input data:

Which we can change with otherItems(). As a parameter, we will specify the schema for each extra element:


You can deprecate property using the deprecated([string $message]) method. Deprecation notices are returned by $processor->getWarnings() (since v1.1):

Ranges: min() max()

Use min() and max() to limit the number of elements for arrays:

For strings, limit their length:

For numbers, limit their value:

Of course, it is possible to mention only min(), or only max():

Regular Expressions: pattern()

Using pattern(), you can specify a regular expression which the whole input string must match (i.e. as if it were wrapped in characters ^ a $):

Custom Assertions: assert()

You can add any other restrictions using assert(callable $fn).


You can add your own description for each assertions. It will be part of the error message.

The method can be called repeatedly to add more assertions.

Mapping to Objects: from()

You can generate structure schema from the class. Example:

If you are using PHP 7.4 or higher, you can use native types:

Anonymous classes are also supported:

Because the information obtained from the class definition may not be sufficient, you can add a custom schema for the elements with the second parameter:

Casting: castTo()

Successfully validated data can be cast:

In addition to native PHP types, you can also cast to classes:

Normalization: before()

Prior to the validation itself, the data can be normalized using the method before(). As an example, let's have an element that must be an array of strings (eg ['a', 'b', 'c']), but receives input in the form of a string a b c:

All versions of schema with dependencies

PHP Build Version
Package Version
Requires php Version >=7.1 <8.3
nette/utils Version ^2.5.7 || ^3.1.5 || ^4.0
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package nette/schema contains the following files

Loading the files please wait ....