diff --git a/application/cs/components.texy b/application/cs/components.texy
index d60ee2b7fd..7b258e0e78 100644
--- a/application/cs/components.texy
+++ b/application/cs/components.texy
@@ -198,7 +198,7 @@ Odkaz, který zavolá signál, vytvoříme obvyklým způsobem, tedy v šabloně
 <a n:href="click! $x, $y">click here</a>
 ```
 
-Signál se vždy volá na aktuálním presenteru a view, tudíž není možné jej vyvolat na jiném presenteru nebo view.
+Signál se vždy volá na aktuálním presenteru a action, není možné jej vyvolat na jiném presenteru nebo jiné action.
 
 Signál tedy způsobí znovunačtení stránky úplně stejně jako při původním požadavku, jen navíc zavolá obslužnou metodu signálu s příslušnými parametry. Pokud metoda neexistuje, vyhodí se výjimka [api:Nette\Application\UI\BadSignalException], která se uživateli zobrazí jako chybová stránka 403 Forbidden.
 
@@ -430,7 +430,7 @@ class PaginatingControl extends Control
 }
 ```
 
-Opačný proces, tedy sesbírání hodnot z persistentních properites, má na starosti metoda `saveState()`.
+Opačný proces, tedy sesbírání hodnot z persistentních properties, má na starosti metoda `saveState()`.
 
 
 Signály do hloubky
@@ -444,7 +444,7 @@ Signál může přijímat jakákoliv komponenta, presenter nebo objekt, který i
 
 Mezi hlavní příjemce signálů budou patřit `Presentery` a vizuální komponenty dědící od `Control`. Signál má sloužit jako znamení pro objekt, že má něco udělat – anketa si má započítat hlas od uživatele, blok s novinkami se má rozbalit a zobrazit dvakrát tolik novinek, formulář byl odeslán a má zpracovat data a podobně.
 
-URL pro signál vytváříme pomocí metody [Component::link() |api:Nette\Application\UI\Component::link()]. Jako parametr `$destination` předáme řetězec `{signal}!` a jako `$args` pole argumentů, které chceme signálu předat. Signál se vždy volá na aktuální view s aktuálními parametry, parametry signálu se jen přidají. Navíc se přidává hned na začátku **parametr `?do`, který určuje signál**.
+URL pro signál vytváříme pomocí metody [Component::link() |api:Nette\Application\UI\Component::link()]. Jako parametr `$destination` předáme řetězec `{signal}!` a jako `$args` pole argumentů, které chceme signálu předat. Signál se vždy volá na aktuálním presenteru a action s aktuálními parametry, parametry signálu se jen přidají. Navíc se přidává hned na začátku **parametr `?do`, který určuje signál**.
 
 Jeho formát je buď `{signal}`, nebo `{signalReceiver}-{signal}`. `{signalReceiver}` je název komponenty v presenteru. Proto nemůže být v názvu komponenty pomlčka – používá se k oddělení názvu komponenty a signálu, je ovšem možné takto zanořit několik komponent.
 
diff --git a/application/el/components.texy b/application/el/components.texy
index ed46dc4e74..9f808f518a 100644
--- a/application/el/components.texy
+++ b/application/el/components.texy
@@ -430,7 +430,7 @@ class PaginatingControl extends Control
 }
 ```
 
-Η αντίθετη διαδικασία, δηλαδή η συλλογή τιμών από persistent properites, αντιμετωπίζεται από τη μέθοδο `saveState()`.
+Η αντίθετη διαδικασία, δηλαδή η συλλογή τιμών από persistent properties, αντιμετωπίζεται από τη μέθοδο `saveState()`.
 
 
 Σήματα σε βάθος .[#toc-signals-in-depth]
diff --git a/application/en/components.texy b/application/en/components.texy
index 42b40aaacb..f6cf8e1e4f 100644
--- a/application/en/components.texy
+++ b/application/en/components.texy
@@ -198,7 +198,7 @@ The link that calls the signal is created in the usual way, i.e. in the template
 <a n:href="click! $x, $y">click here</a>
 ```
 
-The signal is always called on the current presenter and view, so it is not possible to link to signal in different presenter / action.
+The signal is always called on the current presenter and action, it cannot be called on another presenter or action.
 
 Thus, the signal causes the page to be reloaded in exactly the same way as in the original request, only in addition it calls the signal handling method with the appropriate parameters. If the method does not exist, exception [api:Nette\Application\UI\BadSignalException] is thrown, which is displayed to the user as error page 403 Forbidden.
 
@@ -430,7 +430,7 @@ class PaginatingControl extends Control
 }
 ```
 
-The opposite process, that is, collecting values from persistent properites, is handled by the `saveState()` method.
+The opposite process, that is, collecting values from persistent properties, is handled by the `saveState()` method.
 
 
 Signals in Depth
@@ -444,7 +444,7 @@ Signal can be received by any component, presenter of object which implements in
 
 The main receivers of signals are `Presenters` and visual components extending `Control`. A signal is a sign for an object that it has to do something - poll counts in a vote from user, box with news has to unfold, form was sent and has to process data and so on.
 
-The URL for the signal is created using the method [Component::link() |api:Nette\Application\UI\Component::link()]. As parameter `$destination` we pass string `{signal}!` and as `$args` an array of arguments which we want to pass to the signal handler. Signal parameters are attached to the URL of the current presenter/view. **The parameter `?do` in the URL determines the signal called.**
+The URL for the signal is created using the [Component::link() |api:Nette\Application\UI\Component::link()] method. We pass the string `{signal}!` as the `$destination` parameter and the array of arguments we want to pass to the signal as `$args`. The signal is always called on the current presenter and action with the current parameters, the signal parameters are just added. In addition, the **parameter `?do`, which specifies the signal** is added right at the beginning.
 
 Its format is `{signal}` or `{signalReceiver}-{signal}`. `{signalReceiver}` is the name of the component in the presenter. This is why hyphen (inaccurately dash) can't be present in the name of components - it is used to divide the name of the component and signal, but it's possible to compose several components.
 
diff --git a/application/pl/components.texy b/application/pl/components.texy
index 740e5f919e..7cf169bc16 100644
--- a/application/pl/components.texy
+++ b/application/pl/components.texy
@@ -430,7 +430,7 @@ class PaginatingControl extends Control
 }
 ```
 
-Procesem przeciwnym, czyli pobieraniem wartości z persistent properites, zajmuje się metoda `saveState()`.
+Procesem przeciwnym, czyli pobieraniem wartości z persistent properties, zajmuje się metoda `saveState()`.
 
 
 Sygnały w głąb .[#toc-signaly-do-hloubky]
diff --git a/application/pt/components.texy b/application/pt/components.texy
index 9cfe7557f5..2b2df985bc 100644
--- a/application/pt/components.texy
+++ b/application/pt/components.texy
@@ -430,7 +430,7 @@ class PaginatingControl extends Control
 }
 ```
 
-O processo oposto, ou seja, a coleta de valores de properites persistentes, é tratado pelo método `saveState()`.
+O processo oposto, ou seja, a coleta de valores de properties persistentes, é tratado pelo método `saveState()`.
 
 
 Sinais em profundidade .[#toc-signals-in-depth]
diff --git a/best-practices/cs/composer.texy b/best-practices/cs/composer.texy
index 8ea7581472..137b09c745 100644
--- a/best-practices/cs/composer.texy
+++ b/best-practices/cs/composer.texy
@@ -58,7 +58,7 @@ composer update
 
 Composer stáhne Nette Database do složky `vendor/`. Dále vytvoří soubor `composer.lock`, který obsahuje informace o tom, které verze knihoven přesně nainstaloval.
 
-Composer vygeneruje soubor `vendor/autoload.php`, který můžeme jednoduše zainkludovat a začít používat knihovny bez jakékoli další práce:
+Composer vygeneruje soubor `vendor/autoload.php`, který můžeme jednoduše inkludovat a začít používat knihovny bez jakékoli další práce:
 
 ```php
 require __DIR__ . '/vendor/autoload.php';
diff --git a/best-practices/cs/inject-method-attribute.texy b/best-practices/cs/inject-method-attribute.texy
index 9bd667a09f..b3e80f1266 100644
--- a/best-practices/cs/inject-method-attribute.texy
+++ b/best-practices/cs/inject-method-attribute.texy
@@ -61,7 +61,7 @@ class MyPresenter extends Nette\Application\UI\Presenter
 
 Výhodou tohoto způsobu předávání závislostí byla velice úsporná podoba zápisu. Nicméně s příchodem [constructor property promotion |https://blog.nette.org/cs/php-8-0-kompletni-prehled-novinek#toc-constructor-property-promotion] se jeví snazší použít konstruktor.
 
-Naopak tento způsob trpí stejnými nedostatky, jako předávání závislosti do properites obecně: nemáme kontrolu nad změnami v proměnné a zároveň se proměnná stává součástí veřejného rozhraní třídy, což je nežádnoucí.
+Naopak tento způsob trpí stejnými nedostatky, jako předávání závislosti do properties obecně: nemáme kontrolu nad změnami v proměnné a zároveň se proměnná stává součástí veřejného rozhraní třídy, což je nežádnoucí.
 
 
 {{sitename: Best Practices}}
diff --git a/database/cs/upgrading.texy b/database/cs/upgrading.texy
index 0a89ef3585..20bb26d94d 100644
--- a/database/cs/upgrading.texy
+++ b/database/cs/upgrading.texy
@@ -7,7 +7,7 @@ Přechod z verze 3.1 na 3.2
 
 Minimální požadovaná verze PHP je 8.1.
 
-Kód byl pečlivě vyladěn pro PHP 8.1. Byly doplněny všechny nové typehinty u metod a properites. Změny jsou jen drobné:
+Kód byl pečlivě vyladěn pro PHP 8.1. Byly doplněny všechny nové typehinty u metod a properties. Změny jsou jen drobné:
 
 - MySQL: nulové datum `0000-00-00` vrací jako `null`
 - MySQL: decimal bez desetinných míst vrací jako int místo float
diff --git a/forms/bg/validation.texy b/forms/bg/validation.texy
index ba3c97bdce..2f5a38cc3b 100644
--- a/forms/bg/validation.texy
+++ b/forms/bg/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 В Nette е много лесно да се реагира на изпълнението или неизпълнението на дадено условие от страна на JavaScript, като се използва методът `toggle()`, вж. раздел [Динамичен JavaScript |#Динамический JavaScript].
 
 
-Връзки между контролите .[#toc-references-between-controls]
-===========================================================
+Препратка към друг елемент .[#toc-reference-to-another-element]
+===============================================================
 
-Аргумент на правило или условие може да бъде препратка към друг елемент. Например можете динамично да потвърдите, че `text` има толкова знаци, колкото са посочени в полето `length`:
+Като аргумент за правило или условие можете да предадете и друг елемент от формуляра. Тогава правилото ще използва стойността, въведена по-късно от потребителя в браузъра. Това може да се използва например за динамично потвърждаване, че елементът `password` съдържа същия низ като елемента `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/cs/validation.texy b/forms/cs/validation.texy
index 8398dd66d6..919afc032c 100644
--- a/forms/cs/validation.texy
+++ b/forms/cs/validation.texy
@@ -172,7 +172,7 @@ Vlastní pravidla a podmínky
 
 Občas se dostaneme do situace, kdy nám vestavěná validační pravidla v Nette nestačí a potřebujeme data od uživatele validovat po svém. V Nette je to velmi jednoduché!
 
-Metodám `addRule()` či `addCondition()` lze první parametr předat libovolný callback. Ten přijímá jako první parametr samotný prvek a vrací boolean hodnotu určující, zda validace proběhla v pořádku. Při přidávání pravidla pomocí `addRule()` je možné zadat i další argumenty, ty jsou pak předány jako druhý parametr.
+Metodám `addRule()` či `addCondition()` lze jako první parametr předat libovolný callback. Ten přijímá jako první parametr samotný prvek a vrací boolean hodnotu určující, zda validace proběhla v pořádku. Při přidávání pravidla pomocí `addRule()` je možné zadat i další argumenty, ty jsou pak předány jako druhý parametr.
 
 Vlastní sadu validátorů tak můžeme vytvořit jako třídu se statickými metodami:
 
diff --git a/forms/de/validation.texy b/forms/de/validation.texy
index d1a923d128..0abbb2c140 100644
--- a/forms/de/validation.texy
+++ b/forms/de/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 In Nette ist es sehr einfach, auf die Erfüllung oder Nichterfüllung einer Bedingung auf der JavaScript-Seite mit der Methode `toggle()` zu reagieren, siehe [Dynamisches JavaScript |#Dynamic JavaScript].
 
 
-Referenzen zwischen Controls .[#toc-references-between-controls]
-================================================================
+Verweis auf ein anderes Element .[#toc-reference-to-another-element]
+====================================================================
 
-Das Regel- oder Bedingungsargument kann ein Verweis auf ein anderes Element sein. Sie können zum Beispiel dynamisch überprüfen, ob `text` so viele Zeichen hat wie der Wert des Feldes `length` beträgt:
+Als Argument für eine Regel oder Bedingung können Sie auch ein anderes Formularelement übergeben. Die Regel wird dann den Wert verwenden, den der Benutzer später im Browser eingibt. Auf diese Weise kann z. B. dynamisch überprüft werden, ob das Element `password` dieselbe Zeichenfolge enthält wie das Element `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/el/validation.texy b/forms/el/validation.texy
index 68422555e5..7a205ccf3a 100644
--- a/forms/el/validation.texy
+++ b/forms/el/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 Στη Nette, είναι πολύ εύκολο να αντιδράσετε στην εκπλήρωση ή όχι μιας συνθήκης από την πλευρά της JavaScript χρησιμοποιώντας τη μέθοδο `toggle()`, βλέπε [Δυναμική JavaScript |#Dynamic JavaScript].
 
 
-Αναφορές μεταξύ στοιχείων ελέγχου .[#toc-references-between-controls]
-=====================================================================
+Αναφορά σε άλλο στοιχείο .[#toc-reference-to-another-element]
+=============================================================
 
-Το όρισμα του κανόνα ή της συνθήκης μπορεί να είναι μια αναφορά σε ένα άλλο στοιχείο. Για παράδειγμα, μπορείτε να επικυρώσετε δυναμικά ότι το `text` έχει τόσους χαρακτήρες όσοι είναι οι τιμές του πεδίου `length`:
+Ως όρισμα για έναν κανόνα ή συνθήκη, μπορείτε επίσης να περάσετε ένα άλλο στοιχείο της φόρμας. Ο κανόνας θα χρησιμοποιήσει τότε την τιμή που θα εισαχθεί αργότερα από τον χρήστη στο πρόγραμμα περιήγησης. Αυτό μπορεί να χρησιμοποιηθεί, για παράδειγμα, για τη δυναμική επικύρωση ότι το στοιχείο `password` περιέχει την ίδια συμβολοσειρά με το στοιχείο `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/es/validation.texy b/forms/es/validation.texy
index 3a07b00586..8b49641b8d 100644
--- a/forms/es/validation.texy
+++ b/forms/es/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 En Nette, es muy fácil reaccionar al cumplimiento o no de una condición en la parte JavaScript utilizando el método `toggle()`, véase [JavaScript dinámico |#Dynamic JavaScript].
 
 
-Referencias entre Controles .[#toc-references-between-controls]
+Referencia a otro elemento .[#toc-reference-to-another-element]
 ===============================================================
 
-El argumento de la regla o condición puede ser una referencia a otro elemento. Por ejemplo, puede validar dinámicamente que `text` tenga tantos caracteres como el valor del campo `length`:
+Como argumento para una regla o condición, también puede pasar otro elemento del formulario. La regla utilizará entonces el valor introducido posteriormente por el usuario en el navegador. Esto se puede utilizar, por ejemplo, para validar dinámicamente que el elemento `password` contiene la misma cadena que el elemento `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/fr/validation.texy b/forms/fr/validation.texy
index 4d750f7048..479ffcdd3e 100644
--- a/forms/fr/validation.texy
+++ b/forms/fr/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 Dans Nette, il est très facile de réagir à la réalisation ou non d'une condition du côté JavaScript en utilisant la méthode `toggle()`, voir [Dynamic JavaScript |#Dynamic JavaScript].
 
 
-Références entre les contrôles .[#toc-references-between-controls]
-==================================================================
+Référence à un autre élément .[#toc-reference-to-another-element]
+=================================================================
 
-L'argument de la règle ou de la condition peut être une référence à un autre élément. Par exemple, vous pouvez valider dynamiquement que le champ `text` comporte autant de caractères que la valeur du champ `length`:
+En tant qu'argument d'une règle ou d'une condition, vous pouvez également transmettre un autre élément de formulaire. La règle utilisera alors la valeur introduite ultérieurement par l'utilisateur dans le navigateur. Cela peut être utilisé, par exemple, pour valider dynamiquement que l'élément `password` contient la même chaîne de caractères que l'élément `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/hu/validation.texy b/forms/hu/validation.texy
index 3e70858bf0..757fc82906 100644
--- a/forms/hu/validation.texy
+++ b/forms/hu/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 A Nette-ben nagyon egyszerűen reagálhatunk egy feltétel teljesülésére vagy nem teljesülésére a JavaScript oldalán a `toggle()` metódus segítségével, lásd [Dynamic JavaScript |#Dynamic JavaScript].
 
 
-Hivatkozások a vezérlők között .[#toc-references-between-controls]
-==================================================================
+Hivatkozás egy másik elemre .[#toc-reference-to-another-element]
+================================================================
 
-A szabály vagy feltétel argumentum lehet hivatkozás egy másik elemre. Például dinamikusan érvényesítheti, hogy a `text` annyi karaktert tartalmazzon, ahány karakter a `length` mező értéke:
+Egy szabály vagy feltétel argumentumaként egy másik űrlapelemet is átadhat. A szabály ekkor a felhasználó által a böngészőben később megadott értéket fogja használni. Ez például arra használható, hogy dinamikusan ellenőrizze, hogy a `password` elem ugyanazt a karakterláncot tartalmazza-e, mint a `password_confirm` elem:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/it/validation.texy b/forms/it/validation.texy
index b4f71f97c5..d608296e92 100644
--- a/forms/it/validation.texy
+++ b/forms/it/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 In Nette, è molto facile reagire all'adempimento o meno di una condizione sul lato JavaScript, usando il metodo `toggle()`, vedere [JavaScript dinamico |#Dynamic JavaScript].
 
 
-Riferimenti tra controlli .[#toc-references-between-controls]
-=============================================================
+Riferimento a un altro elemento .[#toc-reference-to-another-element]
+====================================================================
 
-L'argomento della regola o della condizione può essere un riferimento a un altro elemento. Ad esempio, è possibile convalidare dinamicamente che il campo `text` abbia un numero di caratteri pari al valore del campo `length`:
+Come argomento per una regola o una condizione, si può passare anche un altro elemento del modulo. La regola utilizzerà il valore inserito successivamente dall'utente nel browser. Questo può essere utilizzato, ad esempio, per convalidare dinamicamente che l'elemento `password` contenga la stessa stringa dell'elemento `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/pl/validation.texy b/forms/pl/validation.texy
index 743ac60ead..c8c6a1b9c6 100644
--- a/forms/pl/validation.texy
+++ b/forms/pl/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 W Nett bardzo łatwo jest również reagować na spełnienie lub niespełnienie warunku po stronie JavaScript za pomocą metody `toggle()`, patrz [dynamiczny JavaScript |#Dynamic-JavaScript].
 
 
-Odniesienia między elementami .[#toc-references-between-controls]
-=================================================================
+Odniesienie do innego elementu .[#toc-reference-to-another-element]
+===================================================================
 
-Odwołanie do innego elementu może być podane jako argument do reguły lub warunku. Tak więc, na przykład, możliwe jest dynamiczne sprawdzenie, czy element `text` ma tyle znaków, ile wynosi wartość elementu `length`:
+Jako argument reguły lub warunku można również przekazać inny element formularza. Reguła użyje wtedy wartości wprowadzonej później przez użytkownika w przeglądarce. Można to wykorzystać na przykład do dynamicznego sprawdzenia, czy element `password` zawiera ten sam ciąg znaków, co element `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/pt/validation.texy b/forms/pt/validation.texy
index 803e9b2a38..25e1c29291 100644
--- a/forms/pt/validation.texy
+++ b/forms/pt/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 Em Nette, é muito fácil reagir ao cumprimento ou não de uma condição no lado JavaScript usando o método `toggle()`, veja [Dynamic JavaScript |#Dynamic JavaScript].
 
 
-Referências entre controles .[#toc-references-between-controls]
-===============================================================
+Referência a outro elemento .[#toc-reference-to-another-element]
+================================================================
 
-A regra ou argumento de condição pode ser uma referência a outro elemento. Por exemplo, você pode validar dinamicamente que o `text` tem tantos caracteres quanto o valor do campo `length`:
+Como argumento para uma regra ou condição, você também pode passar outro elemento de formulário. A regra usará então o valor inserido posteriormente pelo usuário no navegador. Isso pode ser usado, por exemplo, para validar dinamicamente se o elemento `password` contém a mesma cadeia de caracteres que o elemento `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/ro/validation.texy b/forms/ro/validation.texy
index 4ea0350077..2ad6144a72 100644
--- a/forms/ro/validation.texy
+++ b/forms/ro/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 În Nette, este foarte ușor să reacționați la îndeplinirea sau nu a unei condiții pe partea de JavaScript folosind metoda `toggle()`, consultați [Dynamic JavaScript |#Dynamic JavaScript].
 
 
-Referințe între controale .[#toc-references-between-controls]
-=============================================================
+Trimitere la un alt element .[#toc-reference-to-another-element]
+================================================================
 
-Argumentul regulii sau al condiției poate fi o referință la un alt element. De exemplu, puteți valida în mod dinamic faptul că `text` are atâtea caractere cât este valoarea câmpului `length`:
+Ca argument pentru o regulă sau o condiție, puteți trece și un alt element de formular. Regula va utiliza apoi valoarea introdusă ulterior de utilizator în browser. Acest lucru poate fi utilizat, de exemplu, pentru a valida dinamic faptul că elementul `password` conține același șir de caractere ca elementul `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/ru/validation.texy b/forms/ru/validation.texy
index a48bb25189..26b6a03f38 100644
--- a/forms/ru/validation.texy
+++ b/forms/ru/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 В Nette очень легко реагировать на выполнение или невыполнение условия на стороне JavaScript, используя метод `toggle()`, см. [#Динамический JavaScript].
 
 
-Ссылки между элементами управления .[#toc-references-between-controls]
-======================================================================
+Ссылка на другой элемент .[#toc-reference-to-another-element]
+=============================================================
 
-Аргумент правила или условия может быть ссылкой на другой элемент. Например, вы можете динамически подтвердить, что `text` имеет столько символов, сколько указано в поле `length`:
+В качестве аргумента для правила или условия можно также передать другой элемент формы. Тогда правило будет использовать значение, введенное позже пользователем в браузере. Это можно использовать, например, для динамической проверки того, что элемент `password` содержит ту же строку, что и элемент `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/sl/validation.texy b/forms/sl/validation.texy
index ee2fdd7143..96ff85860a 100644
--- a/forms/sl/validation.texy
+++ b/forms/sl/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 V Nette je zelo enostavno reagirati na izpolnitev ali neizpolnitev pogoja na strani JavaScript z uporabo metode `toggle()`, glejte [Dinamični JavaScript |#Dynamic JavaScript].
 
 
-Sklicevanja med kontrolniki .[#toc-references-between-controls]
-===============================================================
+Sklicevanje na drug element .[#toc-reference-to-another-element]
+================================================================
 
-Argument pravila ali pogoja je lahko sklic na drug element. Na primer, dinamično lahko preverite, da ima `text` toliko znakov, kolikor je vrednost polja `length`:
+Kot argument za pravilo ali pogoj lahko posredujete tudi drug element obrazca. Pravilo bo nato uporabilo vrednost, ki jo bo uporabnik kasneje vnesel v brskalnik. To lahko na primer uporabite za dinamično preverjanje, ali element `password` vsebuje isti niz kot element `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/tr/validation.texy b/forms/tr/validation.texy
index 5c1e590924..ee6bf35514 100644
--- a/forms/tr/validation.texy
+++ b/forms/tr/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 Nette, `toggle()` yöntemini kullanarak [JavaScript |#Dynamic JavaScript] tarafında bir koşulun yerine getirilip getirilmemesine tepki vermek çok kolaydır, bkz.
 
 
-Kontroller Arasındaki Referanslar .[#toc-references-between-controls]
-=====================================================================
+Başka Bir Öğeye Referans .[#toc-reference-to-another-element]
+=============================================================
 
-Kural veya koşul bağımsız değişkeni başka bir öğeye referans olabilir. Örneğin, `text` adresinin `length` alanının değeri kadar karaktere sahip olduğunu dinamik olarak doğrulayabilirsiniz:
+Bir kural veya koşul için bağımsız değişken olarak başka bir form öğesi de iletebilirsiniz. Kural daha sonra kullanıcı tarafından tarayıcıda girilen değeri kullanacaktır. Bu, örneğin, `password` öğesinin `password_confirm` öğesiyle aynı dizeyi içerdiğini dinamik olarak doğrulamak için kullanılabilir:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/forms/uk/validation.texy b/forms/uk/validation.texy
index f86c24d604..493745cbfc 100644
--- a/forms/uk/validation.texy
+++ b/forms/uk/validation.texy
@@ -155,15 +155,15 @@ $form->addText(/* ... */)
 У Nette дуже легко реагувати на виконання або невиконання умови на стороні JavaScript, використовуючи метод `toggle()`, див. [Динамічний JavaScript |#Динамический JavaScript].
 
 
-Посилання між елементами керування .[#toc-references-between-controls]
-======================================================================
+Посилання на інший елемент .[#toc-reference-to-another-element]
+===============================================================
 
-Аргумент правила або умови може бути посиланням на інший елемент. Наприклад, ви можете динамічно підтвердити, що `text` має стільки символів, скільки вказано в полі `length`:
+Як аргумент для правила або умови ви також можете передати інший елемент форми. Тоді правило буде використовувати значення, яке користувач введе пізніше в браузері. Це можна використовувати, наприклад, для динамічної перевірки того, що елемент `password` містить той самий рядок, що й елемент `password_confirm`:
 
 ```php
-$form->addInteger('length');
-$form->addText('text')
-	->addRule($form::Length, null, $form['length']);
+$form->addPassword('password', 'Password');
+$form->addPassword('password_confirm', 'Confirm Password')
+    ->addRule($form::Equal, 'The passwords do not match', $form['password']);
 ```
 
 
diff --git a/latte/bg/template-inheritance.texy b/latte/bg/template-inheritance.texy
index f25013bc40..16c179b22a 100644
--- a/latte/bg/template-inheritance.texy
+++ b/latte/bg/template-inheritance.texy
@@ -423,7 +423,7 @@ Hi, I am Mary.
 Хоризонтална повторна употреба `{import}` .{toc: Horizontal Reuse}
 ==================================================================
 
-Хоризонталната повторна употреба е третият механизъм за повторна употреба и наследяване в Latte. Той позволява зареждане на блокове от други шаблони. Това е подобно на създаването на PHP файл с помощни функции или черти.
+Хоризонталната повторна употреба е третият механизъм за повторна употреба и наследяване в Latte. Той позволява зареждане на блокове от други шаблони. Подобно е на създаването на файл с помощни функции в PHP и последващото му зареждане с помощта на `require`.
 
 Въпреки че наследяването на оформлението на шаблона е една от най-мощните функции на Latte, то е ограничено до просто наследяване - един шаблон може да разшири само един друг шаблон. Хоризонталното повторно използване е начин за постигане на многократно наследяване.
 
@@ -455,7 +455,7 @@ Hi, I am Mary.
 
 Можете да използвате толкова изрази `{import}`, колкото искате в даден шаблон. Ако два импортирани шаблона дефинират един и същ блок, печели първият. Най-голям приоритет обаче има основният шаблон, който може да презапише всеки импортиран блок.
 
-Всички надписани блокове могат да бъдат включени постепенно, като се вмъкнат като [родителски блок |#Parent-Block]:
+Съдържанието на презаписаните блокове може да бъде запазено чрез вмъкване на блока по същия начин, както при [родителския блок |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/cs/template-inheritance.texy b/latte/cs/template-inheritance.texy
index 6c62b34f1c..de256ad7ca 100644
--- a/latte/cs/template-inheritance.texy
+++ b/latte/cs/template-inheritance.texy
@@ -423,7 +423,7 @@ Několik užitečných tipů pro efektivní práci s bloky:
 Horizontální znovupoužití `{import}` .{toc: Horizontální znovupoužití}
 ======================================================================
 
-Horizontální znovupoužití je v Latte třetím mechanismem pro opětovné použití a dědičnost. Umožňuje načíst bloky z jiných šablon. Je to podobné jako vytvoření souboru PHP s pomocnými funkcemi.
+Horizontální znovupoužití je v Latte třetím mechanismem pro opětovné použití a dědičnost. Umožňuje načítat bloky z jiných šablon. Je to podobné, jako když si v PHP vytvoříme soubor s pomocnými funkcemi, který potom načítáme pomocí `require`.
 
 I když je layoutová dědičnost šablony jednou z nejsilnějších funkcí Latte, je omezena na jednoduchou dědičnost - šablona může rozšířit pouze jednu další šablonu. Horizontální znovupoužití je způsob, jak dosáhnout vícenásobné dědičnosti.
 
@@ -455,7 +455,7 @@ Značka `{import}` by měla být první značkou šablony po `{layout}`. Název
 
 V šabloně můžete použít tolik `{import}` příkazů, kolik potřebujete. Pokud dvě importované šablony definují stejný blok, má přednost první z nich. Nejvyšší prioritu má ale hlavní šablona, která může přepsat jakýkoli importovaný blok.
 
-Ke všem přepsaným blokům se dá postupně dostat vložením jako [#rodičovský blok]:
+Obsah přepsaných bloků se dá zachovat tak, že blok vložíme stejně, jako se vkládá [#rodičovský blok]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/de/template-inheritance.texy b/latte/de/template-inheritance.texy
index 0f57bdd16e..5e9a307295 100644
--- a/latte/de/template-inheritance.texy
+++ b/latte/de/template-inheritance.texy
@@ -423,7 +423,7 @@ Hier finden Sie einige Tipps für die Arbeit mit Blöcken:
 Horizontale Wiederverwendung `{import}` .{toc: Horizontal Reuse}
 ================================================================
 
-Die horizontale Wiederverwendung ist ein dritter Wiederverwendbarkeits- und Vererbungsmechanismus in Latte. Sie ermöglicht es Ihnen, Blöcke aus anderen Vorlagen zu laden. Es ist vergleichbar mit dem Erstellen einer PHP-Datei mit Hilfsfunktionen oder einem Trait.
+Die horizontale Wiederverwendung ist der dritte Mechanismus für Wiederverwendung und Vererbung in Latte. Er ermöglicht das Laden von Blöcken aus anderen Vorlagen. Dies ist vergleichbar mit der Erstellung einer Datei mit Hilfsfunktionen in PHP und dem anschließenden Laden mit `require`.
 
 Obwohl die Vererbung von Vorlagenlayouts eine der leistungsfähigsten Funktionen von Latte ist, ist sie auf einfache Vererbung beschränkt - eine Vorlage kann nur eine andere Vorlage erweitern. Die horizontale Wiederverwendung ist eine Möglichkeit, Mehrfachvererbung zu erreichen.
 
@@ -455,7 +455,7 @@ Das Tag `{import}` sollte das erste Template-Tag nach `{layout}` sein. Der Vorla
 
 Sie können so viele `{import}` Anweisungen in einer Vorlage verwenden, wie Sie wollen. Wenn zwei importierte Vorlagen denselben Block definieren, gewinnt die erste Vorlage. Die höchste Priorität wird jedoch der Hauptvorlage eingeräumt, die jeden importierten Block überschreiben kann.
 
-Alle überschriebenen Blöcke können nach und nach eingebunden werden, indem sie als [übergeordneter Block |#parent block] eingefügt werden:
+Der Inhalt von überschriebenen Blöcken kann beibehalten werden, indem der Block wie ein [übergeordneter Block |#parent block] eingefügt wird:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/el/template-inheritance.texy b/latte/el/template-inheritance.texy
index 321ee58522..b80ad35c1b 100644
--- a/latte/el/template-inheritance.texy
+++ b/latte/el/template-inheritance.texy
@@ -423,7 +423,7 @@ Hi, I am Mary.
 Οριζόντια επαναχρησιμοποίηση `{import}` .{toc: Horizontal Reuse}
 ================================================================
 
-Η οριζόντια επαναχρησιμοποίηση είναι ένας τρίτος μηχανισμός επαναχρησιμοποίησης και κληρονομικότητας στο Latte. Σας επιτρέπει να φορτώνετε μπλοκ από άλλα πρότυπα. Είναι παρόμοιο με τη δημιουργία ενός αρχείου PHP με βοηθητικές συναρτήσεις ή ένα χαρακτηριστικό γνώρισμα.
+Η οριζόντια επαναχρησιμοποίηση είναι ο τρίτος μηχανισμός επαναχρησιμοποίησης και κληρονομικότητας στο Latte. Επιτρέπει τη φόρτωση μπλοκ από άλλα πρότυπα. Είναι παρόμοιο με τη δημιουργία ενός αρχείου με βοηθητικές συναρτήσεις στην PHP και στη συνέχεια τη φόρτωσή του χρησιμοποιώντας το `require`.
 
 Ενώ η κληρονομικότητα διάταξης προτύπου είναι ένα από τα πιο ισχυρά χαρακτηριστικά του Latte, περιορίζεται στην απλή κληρονομικότητα - ένα πρότυπο μπορεί να επεκτείνει μόνο ένα άλλο πρότυπο. Η οριζόντια επαναχρησιμοποίηση είναι ένας τρόπος για την επίτευξη πολλαπλής κληρονομικότητας.
 
@@ -455,7 +455,7 @@ Hi, I am Mary.
 
 Μπορείτε να χρησιμοποιήσετε όσες δηλώσεις `{import}` θέλετε σε οποιοδήποτε συγκεκριμένο πρότυπο. Αν δύο εισαγόμενα πρότυπα ορίζουν το ίδιο μπλοκ, το πρώτο κερδίζει. Ωστόσο, η υψηλότερη προτεραιότητα δίνεται στο κύριο πρότυπο, το οποίο μπορεί να αντικαταστήσει οποιοδήποτε εισαγόμενο μπλοκ.
 
-Όλα τα μπλοκ που αντικαθίστανται μπορούν να συμπεριληφθούν σταδιακά εισάγοντας τα ως [γονικό μπλοκ |#parent block]:
+Το περιεχόμενο των μπλοκ που έχουν αντικατασταθεί μπορεί να διατηρηθεί με την εισαγωγή του μπλοκ με τον ίδιο τρόπο όπως ένα [γονικό μπλοκ |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/en/template-inheritance.texy b/latte/en/template-inheritance.texy
index 9e734e9382..a4518db3b7 100644
--- a/latte/en/template-inheritance.texy
+++ b/latte/en/template-inheritance.texy
@@ -423,7 +423,7 @@ Here are some tips for working with blocks:
 Horizontal Reuse `{import}` .{toc: Horizontal Reuse}
 ====================================================
 
-The horizontal reuse is a third reusability and inheritance mechanism in Latte. It allows you to load blocks from other templates. It's similar to creating a PHP file with helper functions or a trait.
+Horizontal reuse is the third mechanism for reuse and inheritance in Latte. It allows loading blocks from other templates. It is similar to creating a file with helper functions in PHP and then loading it using `require`.
 
 While template layout inheritance is one of Latte's most powerful features, it is limited to simple inheritance - a template can only extend one other template. Horizontal reuse is a way to achieve multiple inheritance.
 
@@ -455,7 +455,7 @@ The `{import}` tag should be the first template tag after `{layout}`. The templa
 
 You can use as many `{import}` statements as you want in any given template. If two imported templates define the same block, the first one wins. However, the highest priority is given to the main template, which can overwrite any imported block.
 
-All overridden blocks can be included gradually by inserting them as [#parent block]:
+The content of overwritten blocks can be preserved by inserting the block in the same way as a [#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/es/template-inheritance.texy b/latte/es/template-inheritance.texy
index f3d3b430cc..df83b0277c 100644
--- a/latte/es/template-inheritance.texy
+++ b/latte/es/template-inheritance.texy
@@ -423,7 +423,7 @@ Aquí tienes algunos consejos para trabajar con bloques:
 Reutilización horizontal `{import}` .{toc: Horizontal Reuse}
 ============================================================
 
-La reutilización horizontal es un tercer mecanismo de reutilización y herencia en Latte. Permite cargar bloques de otras plantillas. Es similar a crear un archivo PHP con funciones de ayuda o un trait.
+La reutilización horizontal es el tercer mecanismo de reutilización y herencia en Latte. Permite cargar bloques de otras plantillas. Es similar a crear un archivo con funciones de ayuda en PHP y luego cargarlo usando `require`.
 
 Aunque la herencia del diseño de las plantillas es una de las características más potentes de Latte, está limitada a la herencia simple: una plantilla sólo puede extender a otra plantilla. La reutilización horizontal es una forma de lograr una herencia múltiple.
 
@@ -455,7 +455,7 @@ La etiqueta `{import}` debe ser la primera etiqueta de plantilla después de `{l
 
 Puede utilizar tantas expresiones `{import}` como desee en una plantilla determinada. Si dos plantillas importadas definen el mismo bloque, gana la primera. Sin embargo, la mayor prioridad la tiene la plantilla principal, que puede sobrescribir cualquier bloque importado.
 
-Todos los bloques sobrescritos pueden incluirse gradualmente insertándolos como [bloque padre |#parent block]:
+El contenido de los bloques sobrescritos puede conservarse insertando el bloque del mismo modo que un [bloque padre |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/fr/template-inheritance.texy b/latte/fr/template-inheritance.texy
index f8dbf93934..b0a6fdeab9 100644
--- a/latte/fr/template-inheritance.texy
+++ b/latte/fr/template-inheritance.texy
@@ -423,7 +423,7 @@ Voici quelques conseils pour travailler avec des blocs :
 Réutilisation horizontale `{import}` .{toc: Horizontal Reuse}
 =============================================================
 
-La réutilisation horizontale est un troisième mécanisme de réutilisation et d'héritage dans Latte. Elle vous permet de charger des blocs à partir d'autres modèles. C'est similaire à la création d'un fichier PHP avec des fonctions d'aide ou un trait.
+La réutilisation horizontale est le troisième mécanisme de réutilisation et d'héritage dans Latte. Il permet de charger des blocs à partir d'autres modèles. Il est similaire à la création d'un fichier avec des fonctions d'aide en PHP, puis à son chargement à l'aide de `require`.
 
 Bien que l'héritage de modèles soit l'une des fonctionnalités les plus puissantes de Latte, il est limité à l'héritage simple - un modèle ne peut étendre qu'un seul autre modèle. La réutilisation horizontale est un moyen d'obtenir un héritage multiple.
 
@@ -455,7 +455,7 @@ La balise `{import}` doit être la première balise de modèle après `{layout}`
 
 Vous pouvez utiliser autant d'instructions `{import}` que vous le souhaitez dans un modèle donné. Si deux modèles importés définissent le même bloc, le premier l'emporte. Toutefois, la plus haute priorité est accordée au modèle principal, qui peut écraser tout bloc importé.
 
-Tous les blocs remplacés peuvent être inclus progressivement en les insérant comme [bloc parent |#parent block]:
+Le contenu des blocs écrasés peut être préservé en insérant le bloc de la même manière qu'un [bloc parent |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/hu/template-inheritance.texy b/latte/hu/template-inheritance.texy
index 561a7bae06..bed94f1ba5 100644
--- a/latte/hu/template-inheritance.texy
+++ b/latte/hu/template-inheritance.texy
@@ -423,7 +423,7 @@ Tippek .[#toc-tips]
 Vízszintes újrafelhasználás `{import}` .{toc: Horizontal Reuse}
 ===============================================================
 
-A horizontális újrafelhasználás egy harmadik újrafelhasználhatósági és öröklési mechanizmus a Latte-ban. Lehetővé teszi, hogy blokkokat töltsön be más sablonokból. Ez hasonló ahhoz, mintha egy PHP-fájlt hoznál létre segédfüggvényekkel vagy egy tulajdonsággal.
+A horizontális újrafelhasználás a Latte harmadik újrafelhasználási és öröklési mechanizmusa. Lehetővé teszi a blokkok betöltését más sablonokból. Ez hasonló ahhoz, mintha PHP-ben létrehoznánk egy fájlt segédfüggvényekkel, majd betöltenénk a `require` segítségével.
 
 Bár a sablonok elrendezésének öröklése a Latte egyik legerősebb funkciója, az egyszerű öröklésre korlátozódik - egy sablon csak egy másik sablont terjeszthet ki. A horizontális újrafelhasználás egy módja a többszörös öröklés elérésének.
 
@@ -455,7 +455,7 @@ A `{import}` címkének kell lennie az első sabloncímkének a `{layout}` után
 
 Annyi `{import}` utasítást használhat egy adott sablonban, amennyit csak akar. Ha két importált sablon ugyanazt a blokkot definiálja, akkor az első nyer. A legnagyobb prioritást azonban a fő sablon kapja, amely bármelyik importált blokkot felülírhatja.
 
-Minden felülírt blokk fokozatosan bevonható, ha [szülői blokkként |#parent block] beillesztjük őket:
+A felülírt blokkok tartalma megőrizhető a blokknak a [szülő blokkhoz |#parent block] hasonló módon történő beillesztésével:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/it/template-inheritance.texy b/latte/it/template-inheritance.texy
index be6be739eb..3e2123efa0 100644
--- a/latte/it/template-inheritance.texy
+++ b/latte/it/template-inheritance.texy
@@ -423,7 +423,7 @@ Ecco alcuni suggerimenti per lavorare con i blocchi:
 Riutilizzo orizzontale `{import}` .{toc: Horizontal Reuse}
 ==========================================================
 
-Il riutilizzo orizzontale è un terzo meccanismo di riusabilità ed ereditarietà di Latte. Permette di caricare blocchi da altri modelli. È simile alla creazione di un file PHP con funzioni di aiuto o un tratto.
+Il riutilizzo orizzontale è il terzo meccanismo di riutilizzo ed ereditarietà di Latte. Permette di caricare blocchi da altri modelli. È simile alla creazione di un file con funzioni di aiuto in PHP e al suo caricamento tramite `require`.
 
 L'ereditarietà dei layout dei modelli è una delle caratteristiche più potenti di Latte, ma è limitata all'ereditarietà semplice: un modello può estendere solo un altro modello. Il riutilizzo orizzontale è un modo per ottenere l'ereditarietà multipla.
 
@@ -455,7 +455,7 @@ Il tag `{import}` deve essere il primo tag del template dopo `{layout}`. Il nome
 
 Si possono usare tutte le dichiarazioni `{import}` che si vogliono in un dato template. Se due template importati definiscono lo stesso blocco, vince il primo. Tuttavia, la massima priorità è data al modello principale, che può sovrascrivere qualsiasi blocco importato.
 
-Tutti i blocchi sovrascritti possono essere inclusi gradualmente inserendoli come [blocco padre |#parent block]:
+Il contenuto dei blocchi sovrascritti può essere conservato inserendo il blocco nello stesso modo di un [blocco padre |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/ja/template-inheritance.texy b/latte/ja/template-inheritance.texy
index 6ed251797f..026d023a13 100644
--- a/latte/ja/template-inheritance.texy
+++ b/latte/ja/template-inheritance.texy
@@ -423,7 +423,7 @@ Hi, I am Mary.
 水平方向の再利用`{import}` .{toc: Horizontal Reuse}
 ===========================================
 
-水平方向の再利用はLatteの3つ目の再利用性・継承の仕組みです。他のテンプレートからブロックを読み込むことができるようになります。ヘルパー関数やtraitでPHPファイルを作成するのと同じようなものです。
+水平方向の再利用は、Latteにおける再利用と継承の3番目のメカニズムです。他のテンプレートからブロックを読み込むことができます。PHPでヘルパー関数を含むファイルを作成し、`require` を使って読み込むのと似ています。
 
 テンプレートレイアウトの継承はLatteの最も強力な機能の一つですが、単純な継承に限られています。水平方向の再利用は、複数の継承を実現する方法です。
 
@@ -455,7 +455,7 @@ Hi, I am Mary.
 
 `{import}` ステートメントは、任意のテンプレートで好きなだけ使用することができます。インポートされた2つのテンプレートが同じブロックを定義している場合、先に定義されたものが優先されます。ただし、メイン・テンプレートが最も優先され、インポートされたブロックを上書きすることができます。
 
-上書きされたブロックはすべて、[親ブロックとして |#parent block]挿入することで、徐々に含めることができます。
+上書きされたブロックの内容は、[親ブロックと |#parent block]同じようにブロックを挿入することで保持できる：
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/pl/template-inheritance.texy b/latte/pl/template-inheritance.texy
index 25483c9fab..7ad283d542 100644
--- a/latte/pl/template-inheritance.texy
+++ b/latte/pl/template-inheritance.texy
@@ -423,7 +423,7 @@ Kilka wskazówek dotyczących pracy z klockami:
 Ponowne wykorzystanie poziome `{import}` .{toc: Horizontal Reuse}
 =================================================================
 
-Poziome ponowne użycie jest trzecim mechanizmem wielokrotnego użycia i dziedziczenia w Latte. Pozwala na wczytywanie bloków z innych szablonów. Jest to podobne do tworzenia pliku PHP z funkcjami pomocniczymi.
+Horyzontalne ponowne użycie jest trzecim mechanizmem ponownego użycia i dziedziczenia w Latte. Pozwala on na ładowanie bloków z innych szablonów. Jest to podobne do tworzenia pliku z funkcjami pomocniczymi w PHP, a następnie ładowania go za pomocą `require`.
 
 Dziedziczenie układu szablonu jest jedną z najpotężniejszych funkcji Latte, ale jest ograniczone do prostego dziedziczenia - szablon może rozszerzyć tylko jeden inny szablon. Ponowne użycie horyzontalne jest sposobem na osiągnięcie wielokrotnego dziedziczenia.
 
@@ -455,7 +455,7 @@ Znacznik `{import}` powinien być pierwszym znacznikiem szablonu po `{layout}`.
 
 W szablonie możesz użyć dowolnej ilości oświadczeń `{import}`. Jeśli dwa importowane szablony definiują ten sam blok, wygrywa pierwszy. Jednak szablon główny ma najwyższy priorytet i może zastąpić każdy zaimportowany blok.
 
-Do wszystkich nadrzędnych bloków można uzyskać dostęp sekwencyjny, wstawiając je jako [blok |#Parent-Block] nadrzędny:
+Zawartość nadpisanych bloków można zachować, wstawiając blok w taki sam sposób, jak [blok nadrzędny |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/pt/template-inheritance.texy b/latte/pt/template-inheritance.texy
index daf38bde1b..2752e1b8bc 100644
--- a/latte/pt/template-inheritance.texy
+++ b/latte/pt/template-inheritance.texy
@@ -423,7 +423,7 @@ Aqui estão algumas dicas para trabalhar com blocos:
 Reutilização Horizontal `{import}` .{toc: Horizontal Reuse}
 ===========================================================
 
-A reutilização horizontal é um terceiro mecanismo de reusabilidade e herança em Latte. Ele permite carregar blocos de outros modelos. É semelhante à criação de um arquivo PHP com funções de ajuda ou uma característica.
+A reutilização horizontal é o terceiro mecanismo de reutilização e herança no Latte. Ele permite carregar blocos de outros modelos. É semelhante a criar um arquivo com funções auxiliares em PHP e depois carregá-lo usando `require`.
 
 Embora a herança de layout de modelo seja um dos recursos mais avançados do Latte, ela é limitada à herança simples - um modelo só pode estender um outro modelo. A reutilização horizontal é uma forma de obter herança múltipla.
 
@@ -455,7 +455,7 @@ A tag `{import}` deve ser a primeira tag modelo após `{layout}`. O nome do temp
 
 Você pode usar tantas declarações `{import}` quantas quiser em qualquer modelo dado. Se dois gabaritos importados definirem o mesmo bloco, o primeiro ganha. Entretanto, a maior prioridade é dada ao modelo principal, que pode sobrescrever qualquer bloco importado.
 
-Todos os blocos sobrepostos podem ser incluídos gradualmente, inserindo-os como [bloco pai |#parent block]:
+O conteúdo dos blocos sobrescritos pode ser preservado inserindo-se o bloco da mesma forma que um [bloco pai |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/ro/template-inheritance.texy b/latte/ro/template-inheritance.texy
index 4b8ffe5bdc..b5a4618822 100644
--- a/latte/ro/template-inheritance.texy
+++ b/latte/ro/template-inheritance.texy
@@ -423,7 +423,7 @@ Iată câteva sfaturi pentru a lucra cu blocuri:
 Reutilizare orizontală `{import}` .{toc: Horizontal Reuse}
 ==========================================================
 
-Reutilizarea orizontală este un al treilea mecanism de reutilizare și moștenire în Latte. Acesta vă permite să încărcați blocuri din alte șabloane. Este similar cu crearea unui fișier PHP cu funcții ajutătoare sau a unei trăsături.
+Reutilizarea orizontală este al treilea mecanism de reutilizare și moștenire în Latte. Acesta permite încărcarea blocurilor din alte șabloane. Este similar cu crearea unui fișier cu funcții ajutătoare în PHP și apoi încărcarea acestuia folosind `require`.
 
 Deși moștenirea aspectului șablonului este una dintre cele mai puternice caracteristici ale Latte, aceasta este limitată la moștenirea simplă - un șablon poate extinde doar un alt șablon. Reutilizarea orizontală este o modalitate de a obține moștenirea multiplă.
 
@@ -455,7 +455,7 @@ Eticheta `{import}` trebuie să fie prima etichetă de șablon după `{layout}`.
 
 Puteți utiliza oricâte declarații `{import}` doriți în cadrul unui șablon dat. În cazul în care două șabloane importate definesc același bloc, primul câștigă. Cu toate acestea, prioritatea cea mai mare este acordată șablonului principal, care poate suprascrie orice bloc importat.
 
-Toate blocurile suprascrise pot fi incluse treptat prin inserarea lor ca [bloc părinte |#parent block]:
+Conținutul blocurilor suprascrise poate fi păstrat prin inserarea blocului în același mod ca un [bloc părinte |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/ru/template-inheritance.texy b/latte/ru/template-inheritance.texy
index 362f08b420..20c62c1102 100644
--- a/latte/ru/template-inheritance.texy
+++ b/latte/ru/template-inheritance.texy
@@ -423,7 +423,7 @@ Hi, I am Mary.
 Горизонтальное повторное использование `{import}` .{toc: Horizontal Reuse}
 ==========================================================================
 
-Горизонтальное повторное использование - это третий механизм повторного использования и наследования в Latte. Он позволяет загружать блоки из других шаблонов. Это похоже на создание PHP-файла с вспомогательными функциями или трейтом.
+Горизонтальное повторное использование - это третий механизм повторного использования и наследования в Latte. Он позволяет загружать блоки из других шаблонов. Это похоже на создание файла с вспомогательными функциями в PHP и последующую его загрузку с помощью `require`.
 
 Хотя наследование макетов шаблонов является одной из наиболее мощных возможностей Latte, оно ограничено простым наследованием - шаблон может расширять только один другой шаблон. Горизонтальное повторное использование - это способ достижения множественного наследования.
 
@@ -455,7 +455,7 @@ Hi, I am Mary.
 
 Вы можете использовать столько выражений `{import}`, сколько хотите, в любом данном шаблоне. Если два импортированных шаблона определяют один и тот же блок, побеждает первый. Однако наивысший приоритет отдается главному шаблону, который может перезаписать любой импортированный блок.
 
-Все переопределенные блоки можно включать постепенно, вставляя их в качестве [родительского блока |#Parent-Block]:
+Содержимое перезаписываемых блоков можно сохранить, вставив блок так же, как и [родительский блок |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/sl/template-inheritance.texy b/latte/sl/template-inheritance.texy
index d749775406..dde9554882 100644
--- a/latte/sl/template-inheritance.texy
+++ b/latte/sl/template-inheritance.texy
@@ -423,7 +423,7 @@ Tukaj je nekaj nasvetov za delo z bloki:
 Vodoravna ponovna uporaba `{import}` .{toc: Horizontal Reuse}
 =============================================================
 
-Horizontalna ponovna uporaba je tretji mehanizem ponovne uporabe in dedovanja v Latte. Omogoča nalaganje blokov iz drugih predlog. To je podobno ustvarjanju datoteke PHP s pomožnimi funkcijami ali lastnostmi.
+Horizontalna ponovna uporaba je tretji mehanizem za ponovno uporabo in dedovanje v Latte. Omogoča nalaganje blokov iz drugih predlog. Podobno je, kot če bi v PHP ustvarili datoteko s pomožnimi funkcijami in jo nato naložili z uporabo spletne strani `require`.
 
 Čeprav je dedovanje postavitve predloge ena od najmočnejših funkcij sistema Latte, je omejeno na preprosto dedovanje - predloga lahko razširi le eno drugo predlogo. Horizontalna ponovna uporaba je način za doseganje večkratnega dedovanja.
 
@@ -455,7 +455,7 @@ Oznaka `{import}` mora biti prva oznaka predloge za `{layout}`. Ime predloge je
 
 V posamezni predlogi lahko uporabite poljubno število izrazov `{import}`. Če dve uvoženi predlogi definirata isti blok, zmaga prva. Vendar ima največjo prednost glavna predloga, ki lahko prepiše kateri koli uvoženi blok.
 
-Vse prepisane bloke lahko postopoma vključite tako, da jih vstavite kot [nadrejeni blok |#parent block]:
+Vsebino prepisanih blokov lahko ohranite tako, da blok vstavite na enak način kot [nadrejeni blok |#parent block]:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/tr/template-inheritance.texy b/latte/tr/template-inheritance.texy
index b681815e53..216ec73eb3 100644
--- a/latte/tr/template-inheritance.texy
+++ b/latte/tr/template-inheritance.texy
@@ -423,7 +423,7 @@ Blokların varlığı da fonksiyon tarafından döndürülür [`hasBlock()` |fun
 Yatay Yeniden Kullanım `{import}` .{toc: Horizontal Reuse}
 ==========================================================
 
-Yatay yeniden kullanım, Latte'deki üçüncü bir yeniden kullanılabilirlik ve kalıtım mekanizmasıdır. Diğer şablonlardan bloklar yüklemenizi sağlar. Yardımcı fonksiyonlar veya bir özellik içeren bir PHP dosyası oluşturmaya benzer.
+Yatay yeniden kullanım, Latte'de yeniden kullanım ve kalıtım için üçüncü mekanizmadır. Diğer şablonlardan blokların yüklenmesine izin verir. PHP'de yardımcı işlevlerle bir dosya oluşturmaya ve ardından `require` kullanarak yüklemeye benzer.
 
 Şablon düzeni kalıtımı Latte'nin en güçlü özelliklerinden biri olsa da, basit kalıtımla sınırlıdır - bir şablon yalnızca bir başka şablonu genişletebilir. Yatay yeniden kullanım, çoklu kalıtım elde etmenin bir yoludur.
 
@@ -455,7 +455,7 @@ Ana şablondaki blokları içe aktarırsanız (yani `{import}` adresini `layout.
 
 Herhangi bir şablonda istediğiniz kadar `{import}` ifadesi kullanabilirsiniz. İki içe aktarılan şablon aynı bloğu tanımlarsa, ilki kazanır. Ancak, en yüksek öncelik, içe aktarılan herhangi bir bloğun üzerine yazabilen ana şablona verilir.
 
-Geçersiz kılınan tüm bloklar, [üst |#parent block] blok olarak eklenerek kademeli olarak dahil edilebilir:
+Üzerine yazılan blokların içeriği, blok bir [üst blokla |#parent block] aynı şekilde eklenerek korunabilir:
 
 ```latte
 {layout 'layout.latte'}
diff --git a/latte/uk/template-inheritance.texy b/latte/uk/template-inheritance.texy
index c4fd39ba89..8f16189a33 100644
--- a/latte/uk/template-inheritance.texy
+++ b/latte/uk/template-inheritance.texy
@@ -423,7 +423,7 @@ Hi, I am Mary.
 Горизонтальне повторне використання `{import}` .{toc: Horizontal Reuse}
 =======================================================================
 
-Горизонтальне повторне використання - це третій механізм повторного використання та успадкування в Latte. Він дозволяє завантажувати блоки з інших шаблонів. Це схоже на створення PHP-файлу з допоміжними функціями або трейтом.
+Горизонтальне повторне використання - це третій механізм повторного використання та успадкування в Latte. Він дозволяє завантажувати блоки з інших шаблонів. Це схоже на створення файлу з допоміжними функціями в PHP, а потім завантаження його за допомогою `require`.
 
 Хоча успадкування шаблонів є однією з найпотужніших функцій Latte, воно обмежується простим успадкуванням - шаблон може розширювати лише один інший шаблон. Горизонтальне повторне використання - це спосіб досягти множинного успадкування.
 
@@ -455,7 +455,7 @@ Hi, I am Mary.
 
 Ви можете використовувати стільки виразів `{import}`, скільки хочете, у будь-якому даному шаблоні. Якщо два імпортованих шаблони визначають один і той самий блок, перемагає перший. Однак найвищий пріоритет віддається головному шаблону, який може перезаписати будь-який імпортований блок.
 
-Усі перевизначені блоки можна включати поступово, вставляючи їх як [батьківський блок |#Parent-Block]:
+Вміст перезаписаних блоків можна зберегти, вставивши його так само, як і [батьківський блок |#parent block]:
 
 ```latte
 {layout 'layout.latte'}