spanish guide translation

docs/guide-es/rest-authentication.md

+Autenticación
+==============
+
+A diferencia de las aplicaciones Web, las API RESTful son usualmente sin estado (stateless), lo que permite que las sesiones o las cookies no sean usadas. Por lo tanto, cada petición debe llevar alguna suerte de credenciales de autenticación, porque la autenticación del usuario no puede ser mantenida por las sesiones o las cookies. Una práctica común es enviar una pieza (token) secreta de acceso con cada petición para autenticar al usuario. Dado que una pieza de autenticación puede ser usada para identificar y autenticar solamente a un usuario, **el API de peticiones tiene que ser siempre enviado vía HTTPS para prevenir ataques que intervengan en la transmisión "man-in-the-middle" (MitM) **.
+> Tip: Sin estado (stateless) se refiere a un protocolo en el que cada petición es una transacción independiente del resto de peticiones y la comunicación consiste en pares de peticion y respuesta, por lo que no es necesario retener información en la sesión.
+
+Hay muchas maneras de enviar una pieza (token) de acceso:
+
+* [Autorización Básica HTTP (HTTP Basic Auth)](http://en.wikipedia.org/wiki/Basic_access_authentication): la pieza de acceso es enviada como nombre de usuario. Esto sólo debe de ser usado cuando la pieza de acceso puede ser guardada de forma segura en la parte del API del consumidor. Por ejemplo, el API del consumidor es un programa ejecutándose en un servidor.
+* Parámetro de la consulta: la pieza de acceso es enviada como un parámetro de la consulta en la URL de la API, p.e.,
+  `https://example.com/users?access-token=xxxxxxxx`. Debido que muchos servidores dejan los parámetros de consulta en los logs del servidor esta aproximación suele ser usada principalmente para servir peticiones `JSONP` que  no usen las cabeceras HTTP para enviar piezas de acceso.
+* [OAuth 2](http://oauth.net/2/): la pieza de acceso es obtenida por el consumidor por medio de una autorización del servidor y enviada al API del servidor según el protocolo OAuth 2 [Piezas HTTP de la portadora (HTTP Bearer Tokens)](http://tools.ietf.org/html/rfc6750).
+
+Yii soporta todos los métodos anteriores de autenticación. Puedes crear nuevos métodos de autenticación de una forma fácil.
+
+Para activar la autenticación para tus APIs, sigue los pasos siguientes:
+
+1. Configura la propiedad [[yii\web\User::enableSession|enableSession]] de el componente  `user`  de la aplicación a false.
+2. Especifica cuál método de autenticación planeas usar configurando la funcionalidad  `authenticator` en las clases de la controladora REST.
+3. Implementa [[yii\web\IdentityInterface::findIdentityByAccessToken()]] en tu [[yii\web\User::identityClass|clase de identidad de usuario]].
+
+El paso 1 no es necesario pero sí recomendable para las APIs RESTful, pues son sin estado (stateless). Cuando [[yii\web\User::enableSession|enableSession]]
+es false, el estado de autenticación del usuario puede NO ser mantenido (persisted) durante varias peticiones usando sesiones. Si embargo, la autenticación puede ser realizada para cada petición, la cual es realizada por los pasos 2 y 3.
+
+> Tip: Puede configurar [[yii\web\User::enableSession|enableSession]] del componente de la aplicación `user` en la configuración de las aplicaciones si estás desarrollando APIs RESTful en términos de un aplicación. Si desarrollas un módulo de las APIs RESTful, puedes poner la siguiente línea en el método del módulo `init()`, tal y como sigue:
+> ```php
+public function init()
+{
+    parent::init();
+    \Yii::$app->user->enableSession = false;
+}
+```
+
+Por ejemplo, para usar HTTP Basic Auth, puedes configurar `authenticator` como sigue,
+
+```php
+use yii\filters\auth\HttpBasicAuth;
+
+public function behaviors()
+{
+    $behaviors = parent::behaviors();
+    $behaviors['authenticator'] = [
+        'class' => HttpBasicAuth::className(),
+    ];
+    return $behaviors;
+}
+```
+
+Si quires implementar las tres autenticaciones explicadas antes, puedes usar `CompositeAuth` de la siguiente manera,
+
+```php
+use yii\filters\auth\CompositeAuth;
+use yii\filters\auth\HttpBasicAuth;
+use yii\filters\auth\HttpBearerAuth;
+use yii\filters\auth\QueryParamAuth;
+
+public function behaviors()
+{
+    $behaviors = parent::behaviors();
+    $behaviors['authenticator'] = [
+        'class' => CompositeAuth::className(),
+        'authMethods' => [
+            HttpBasicAuth::className(),
+            HttpBearerAuth::className(),
+            QueryParamAuth::className(),
+        ],
+    ];
+    return $behaviors;
+}
+```
+
+Cada elemento en `authMethods` debe de ser el nombre de un método de autenticación de una clase o un array de configuración.
+
+
+La implementación de `findIdentityByAccessToken()` es específico de la aplicación. Por ejemplo, en escenarios simples cuando cada usuario sólo puede terner una pieza (token) de acceso, puedes almacenar la pieza de acceso en la columna `access_token`  en la tabla de usuario. El método debe de ser inmediatamente implementado en la clase  `User` como sigue,
+
+```php
+use yii\db\ActiveRecord;
+use yii\web\IdentityInterface;
+
+class User extends ActiveRecord implements IdentityInterface
+{
+    public static function findIdentityByAccessToken($token, $type = null)
+    {
+        return static::findOne(['access_token' => $token]);
+    }
+}
+```
+
+Después que la autenticación es activada, tal y como se describe arriba, para cada petición de la API, la controladora solicitada puede intentar autenticar al usuario  en su paso  `beforeAction()`.
+
+Si la autenticación ocurre, la controladora puede realizar otras comprobaciones (como son límite del ratio, autorización) y entonces ejecutar la acción. La identidad del usuario autenticado puede ser recogida via `Yii::$app->user->identity`.
+
+Si la autenticación falla, una respuesta con estado HTTP 401 puede ser devuelta junto con otras cabeceras apropiadas (como son la cabecera para autenticación básica HTTP `WWW-Authenticate` ).
+
+
+## Autorización <a name="authorization"></a>
+
+Después de que un usuario se ha autenticado, probablementer querrás comprobar si él o ella tiene los permisos para realizar la acción pedida para el recurso pedido. Este proceso es llamado *autorización (authorization)* y está cubierto en detalle en la [Sección de Autorización](security-authorization.md).
+
+Si tus controladoras extienden de [[yii\rest\ActiveController]], puedes sobreescribir (override) el método [[yii\rest\Controller::checkAccess()|checkAccess()]] para realizar la comprobación de la autorización. El método será llamado por las acciones contenidas en [[yii\rest\ActiveController]].

docs/guide-es/rest-error-handling.md

+Manejo de errores
+==============
+
+Cuando se maneja una petición del API RESTful, si ocurre un error en la petición del usuario o si algo inesperado ocurre en el servidor, simplemente puedes lanzar una excepción para notificar al usuario que algo erróneo ocurrió.
+Si puedes identificar la causa del error (p.e., el recurso pedido no existe), debes considerar lanzar una excepción con el apropiado códig HTTP de estado (p.e., [[yii\web\NotFoundHttpException]] representa un código de estado 404). Yii enviará la respuesta a continuación con el correspondiente código de estado HTTP y el texto. Yii puede incluir también la representación serializada de la excepción en el cuerpo de la respuesta. Por ejemplo:
+
+```
+HTTP/1.1 404 Not Found
+Date: Sun, 02 Mar 2014 05:31:43 GMT
+Server: Apache/2.2.26 (Unix) DAV/2 PHP/5.4.20 mod_ssl/2.2.26 OpenSSL/0.9.8y
+Transfer-Encoding: chunked
+Content-Type: application/json; charset=UTF-8
+
+{
+    "name": "Not Found Exception",
+    "message": "El recurso solicitado no ha sido encontrado.",
+    "code": 0,
+    "status": 404
+}
+```
+
+La siguiente lista sumariza los códigos de estado HTTP que son usados por el framework REST:
+
+* `200`: OK. Todo ha funcionado como se esperaba.
+* `201`: El recurso ha creado con éxito en respuesta a la petición `POST`. La cabecera de situación `Location`  contiene la URL apuntando al nuevo recurso creado.
+* `204`: La petición ha sido manejada con éxito y el cuerpo de la respuesta no tiene contenido (como una petición `DELETE`).
+* `304`: El recurso no ha sido modificado. Puede usar la versión en caché.
+* `400`: Petición errónea. Esto puede estar causado por varias acciones de el usuario, como proveer un JSON no válido en el cuerpo de la petición, proveyendo parámetros de acción no válidos, etc.
+* `401`: Autenticación fallida.
+* `403`: El usuario autenticado no tiene permitido acceder a la API final.
+* `404`: El recurso pedido no existe.
+* `405`: Método no permitido. Por favor comprueba la cabecera `Allow` por los métodos HTTP permitidos.
+* `415`: Tipo de medio no soportado. El tipo de contenido pedido o el número de versión no es válido.
+* `422`: La validación de datos ha fallado (en respuesta a una petición `POST` , por ejemplo). Por favor, comprobad en el cuerpo de la respuesta el mensaje detallado.
+* `429`: Demasiadas peticiones. La petición ha sido rechazada debido a un limitación de rango.
+* `500`: Error interno del servidor. Esto puede estar causado por errores internos  del programa.
+
+
+## Personalizando la Respuesta al Error <a name="customizing-error-response"></a>
+
+A veces puedes querer personalizar el formato de la respuesta del error por defecto . Por ejemplo, en lugar de depender del uso de diferentes estados HTTP para indicar los diferentes errores, puedes querer usar siempre el estado HTTP 200 y encajonar el código de estado HTTP en la respuesta, tal y como se ve en lo que sigue,
+
+```
+HTTP/1.1 200 OK
+Date: Sun, 02 Mar 2014 05:31:43 GMT
+Server: Apache/2.2.26 (Unix) DAV/2 PHP/5.4.20 mod_ssl/2.2.26 OpenSSL/0.9.8y
+Transfer-Encoding: chunked
+Content-Type: application/json; charset=UTF-8
+
+{
+    "success": false,
+    "data": {
+        "name": "Not Found Exception",
+        "message": "The requested resource was not found.",
+        "code": 0,
+        "status": 404
+    }
+}
+```
+
+Para lograr este objetivo, puedes responder al evento `beforeSend` de el componente `response` en la configuración de la aplicación:
+
+```php
+return [
+    // ...
+    'components' => [
+        'response' => [
+            'class' => 'yii\web\Response',
+            'on beforeSend' => function ($event) {
+                $response = $event->sender;
+                if ($response->data !== null && !empty(Yii::$app->request->get['suppress_response_code'])) {
+                    $response->data = [
+                        'success' => $response->isSuccessful,
+                        'data' => $response->data,
+                    ];
+                    $response->statusCode = 200;
+                }
+            },
+        ],
+    ],
+];
+```
+
+El anterior código puede reformatear la respuesta (para ambas respuestas, exitosa o fallida) de forma aclaratoria cuando
+`suppress_response_code` es pasado como un parámetro `GET`.

docs/guide-es/rest-rate-limiting.md

+Limitando el ratio (rate)
+=============
+
+Para prevenir el abuso, puedes considerar añadir un *límitación del ratio* (*rate limiting*) para tus APIs. Por ejemplo, puedes querer limitar el uso del API de cada usuario que no sea como mucho 100 llamadas al API dentro de un periodo de 10 minutos. Si demasiadas peticiones son recibidas de un usuario dentro del periodo de tiempo declarado , una respuesta con código de estado 429 (significa "Demasiadas peticiones") puede ser devuelto.
+
+Para activar la limitación de ratio, la clase [[yii\web\User::identityClass|user identity class]] debe implementar [[yii\filters\RateLimitInterface]].
+Este interface requiere la implementación de tres métodos:
+
+* `getRateLimit()`: devuelve el número máximo de peticiones permitidas y el periodo de tiempo (p.e., `[100, 600]` significa que como mucho puede haber 100 llamadas al API dentro de 600 segundos).
+* `loadAllowance()`: devuelve el número de peticiones que quedan permitidas y el tiempo (fecha/hora) UNIX con el último límite del ratio que ha sido comprobado.
+* `saveAllowance()`: guarda ambos, el número que quedan de peticiones permitidas y el actual tiempo (fecha/hora) UNIX .
+
+Tu puedes usar dos columnas en la tabla de usuario para guardar la información de lo permitido y la fecha/hora (timestamp). Con ambas definidas, entonces `loadAllowance()` y `saveAllowance()` pueden ser implementadas para leer y guardar los valores de las dos columnas correspondientes al actual usuario autenticado. Para mejorar el desempeño, también puedes considerar almacenar esas piezas de información en caché o almacenamiento NoSQL.
+
+Una vez que la clase de identidad implementa el requerido interface, Yii puede usar automáticamente [[yii\filters\RateLimiter]] configurado como una acción de filtrado para [[yii\rest\Controller]] y mejorar la comprobación del limitador de ratio. El limitador de ratio puede lanzar una [[yii\web\TooManyRequestsHttpException]] cuando el límite del ratio es excedido.
+
+Puedes configurar el limitador de ratio en tu clase REST de la controladora como sigue:
+
+```php
+public function behaviors()
+{
+    $behaviors = parent::behaviors();
+    $behaviors['rateLimiter']['enableRateLimitHeaders'] = false;
+    return $behaviors;
+}
+```
+
+Cuando la limitación de ratio está activada, por defecto cada respuesta puede ser enviada con las siguientes cabeceras de HTTP conteniendo la información actual del límite de ratio:
+
+* `X-Rate-Limit-Limit`, el máximo número de peticiones permitidas en un periodo de tiempo
+* `X-Rate-Limit-Remaining`, el número de peticiones restantes en el periodo de tiempo actual
+* `X-Rate-Limit-Reset`, el número de segundos a esperar para pedir el máximo número de peticiones permitidas
+
+Puedes desactivar estas cabeceras configurando [[yii\filters\RateLimiter::enableRateLimitHeaders]] a false, tal y como en el anterior ejemplo.

docs/guide-es/rest-resources.md

+Recursos
+=========
+
+Las APIs RESTful lo son todos para acceder y manipular *recursos (resources)*. Puedes observar los recursos en el paradigma MVC en [Modelos (models)](structure-models.md) .
+
+Mientras que no hay restricción a cómo representar un recurso, en YII usualmente, puedes representar recursos como objetos de la clase [[yii\base\Model]] o sus clases hijas (p.e. [[yii\db\ActiveRecord]]), por las siguientes razones:
+
+* [[yii\base\Model]] implementa el interface [[yii\base\Arrayable]] , el cual te permite personalizar como exponer los datos de los recursos a travès de las APIs RESTful.
+* [[yii\base\Model]] soporta [Validación de entrada (input validation)](input-validation.md), lo cual es muy usado en las APIs RESTful para soportar la entrada de datos.
+* [[yii\db\ActiveRecord]] provee un poderoso soporte para el acceso a datos en bases de datos y su manipulación, lo que lo le hace servir perfectamente si sus recursos de datos están en bases de datos.
+
+En esta sección, vamos principalmente a describir como la clase con recursos que extiende de [[yii\base\Model]] (o sus clases hijas) puede especificar qué datos puede ser devueltos vía las APIs RESTful. Si la clase de los recursos no extiende de [[yii\base\Model]], entonces todas las variables públicas miembro serán devueltas.
+
+
+## Campos (fields) <a name="fields"></a>
+
+Cuando incluimos un recurso en una respuesta de la API RESTful, el recurso necesita ser serializado en una cadena.
+Yii divide este proceso en dos pasos. Primero, el recurso es convertido en un array por [[yii\rest\Serializer]].
+Segundo, el array es serializado en una cadena en  el formato requerido (p.e. JSON, XML) por [[yii\web\ResponseFormatterInterface|response formatters]]. El primer paso es en el que debes de concentrarte principalmente cuando desarrolles una clase de un recurso.
+
+Sobreescribiendo [[yii\base\Model::fields()|fields()]] y/o [[yii\base\Model::extraFields()|extraFields()]],
+puedes especificar qué datos, llamados *fields*, en el recursos, pueden ser colocados en el array que le representa.
+La diferencia entre estos dos métodos es que el primero especifica el conjunto de campos por defecto que deben ser incluidos en el array que los representa, mientras que el último especifica campos adicionales que deben de ser incluidos en el array si una petición del usuario final para ellos vía el parámetro de consulta `expand`. Por ejemplo,
+
+```
+// devuelve todos los campos declarados en fields()
+http://localhost/users
+
+// sólo devuelve los campos id y email, provistos por su declaración en fields()
+http://localhost/users?fields=id,email
+
+// devuelve todos los campos en fields() y el campo profile siempre y cuando esté declarado en extraFields()
+http://localhost/users?expand=profile
+
+// sólo devuelve los campos id, email y profile, siempre y cuando ellos estén declarados en fields() y extraFields()
+http://localhost/users?fields=id,email&expand=profile
+```
+
+
+### Sobreescribiendo `fields()` <a name="overriding-fields"></a>
+
+Por defecto, [[yii\base\Model::fields()]] devuelve todos los atributos de los modelos como si fueran campos, mientras [[yii\db\ActiveRecord::fields()]] sólo devuelve los atributos que tengan datos en la base de datos.
+
+Puedes sobreescribir `fields()` para añadir, quitar, renombrar o redefinir campos. El valor de retorno de `fields()` ha de estar en un array. Las claves del array son los nombres de los campos y los valores del array son las correspondientes definiciones de los campos que pueden ser tanto nombres de propiedades/atributos o funciones anónimas que devuelven los correspondientes valores del los campos. En el caso especial de que el nombre de un campo sea el mismo que su definición puedes omitir la clave en el array. Por ejemplo,
+
+```php
+// explícitamente lista cada campo, siendo mejor usarlo cuando quieras asegurarte que los cambios
+// en una tabla de la base de datos o en un atributo del modelo no provoque el cambio de tu campo (para mantener la compatibilidad anterior).
+public function fields()
+{
+    return [
+        // el nombre de campo es el mismo nombre del atributo
+        'id',
+        // el nombre del campo es "email", su atributo se denomina "email_address"
+        'email' => 'email_address',
+        // el nombre del campo es "name", su valor es definido está definido por una función anónima de retrollamada (callback)
+        'name' => function () {
+            return $this->first_name . ' ' . $this->last_name;
+        },
+    ];
+}
+
+// el ignorar algunos campos, es mejor usarlo cuando heredas de una implementación padre
+// y pones en la lista negra (blacklist) algunos campos sensibles
+public function fields()
+{
+    $fields = parent::fields();
+
+    // quita los campos con información sensible
+    unset($fields['auth_key'], $fields['password_hash'], $fields['password_reset_token']);
+
+    return $fields;
+}
+```
+
+> Atención: Dado que, por defecto, todos los atributos de un modelo pueden ser incluidos en la devolución del API, debes
+> examinar tus datos para estar seguro de que no contiene información sensible. Si se da este tipo de información,
+> debes sobreescribir `fields()` para filtrarlos. En el ejemplo anterior, escogemos
+> quitar `auth_key`, `password_hash` y `password_reset_token`.
+
+
+### Sobreescribiendo `extraFields()` <a name="overriding-extra-fields"></a>
+
+Por defecto, [[yii\base\Model::extraFields()]] no devuelve nada, mientras que [[yii\db\ActiveRecord::extraFields()]] devuelve los nombres de las relaciones que tienen datos (populated) obtenidos de la base de datos.
+
+El formato de devolución de los datos de `extraFields()` es el mismo que el de `fields()`. Usualmente, `extraFields()` es principalmente usado para especificar campos cuyos valores sean objetos. Por ejemplo, dado la siguiente declaración de campo,
+
+```php
+public function fields()
+{
+    return ['id', 'email'];
+}
+
+public function extraFields()
+{
+    return ['profile'];
+}
+```
+
+la petición `http://localhost/users?fields=id,email&expand=profile` puede devolver los siguientes datos en formato JSON :
+
+```php
+[
+    {
+        "id": 100,
+        "email": "100@example.com",
+        "profile": {
+            "id": 100,
+            "age": 30,
+        }
+    },
+    ...
+]
+```
+
+
+## Enlaces (Links) <a name="links"></a>
+
+[HATEOAS](http://en.wikipedia.org/wiki/HATEOAS), es una abreviación de Hipermedia es el Motor del Estado de la Aplicación (Hypermedia as the Engine of Application State), promueve que las APIs RESTfull devuelvan información que permita a los clientes descubrir las acciones que soportan los recursos devueltos. El sentido de HATEOAS es devolver un conjunto de hiperenlaces con relación a la información, cuando los datos de los recursos son servidos por las APIs.
+
+Las clases con recursos pueden soportar HATEOAS implementando el interfaz [[yii\web\Linkable]] . El interfaz contiene sólo un método [[yii\web\Linkable::getLinks()|getLinks()]] el cual debe de de devolver una lista de  [[yii\web\Link|links]].
+Típicamente, debes devolver al menos un enlace `self` representando la URL al mismo recurso objeto. Por ejemplo,
+
+```php
+use yii\db\ActiveRecord;
+use yii\web\Link;
+use yii\web\Linkable;
+use yii\helpers\Url;
+
+class User extends ActiveRecord implements Linkable
+{
+    public function getLinks()
+    {
+        return [
+            Link::REL_SELF => Url::to(['user/view', 'id' => $this->id], true),
+        ];
+    }
+}
+```
+
+Cuando un objeto `User` es devuelto en una respuesta, puede contener un elemento  `_links` representando los enlaces relacionados con el usuario, por ejemplo,
+
+```
+{
+    "id": 100,
+    "email": "user@example.com",
+    // ...
+    "_links" => [
+        "self": "https://example.com/users/100"
+    ]
+}
+```
+
+
+## Colecciones <a name="collections"></a>
+
+Los objetos de los recursos pueden ser agrupados en  *collections*. Cada colección contiene una lista de recursos objeto del mismo tipo.
+
+Las colecciones pueden ser representadas como arrays pero, es usualmente más deseable representarlas como [proveedores de datos (data providers)](output-data-providers.md). Esto es así porque los proveedores de datos soportan paginación y ordenación de los recursos, lo cual es comunmente necesario en las colecciones devueltas con las APIs RESTful. Por ejemplo, la siguiente acción devuelve un proveedor de datos sobre los recursos post:
+
+```php
+namespace app\controllers;
+
+use yii\rest\Controller;
+use yii\data\ActiveDataProvider;
+use app\models\Post;
+
+class PostController extends Controller
+{
+    public function actionIndex()
+    {
+        return new ActiveDataProvider([
+            'query' => Post::find(),
+        ]);
+    }
+}
+```
+
+Cuando un proveedor de datos está enviando una respuesta con el API RESTful, [[yii\rest\Serializer]] llevará la actual página de los recursos y los serializa como un array de recursos objeto. Adicionalmente, [[yii\rest\Serializer]]
+puede incluir también la información de paginación a través de las cabeceras HTTP siguientes:
+
+* `X-Pagination-Total-Count`: Número total de recursos;
+* `X-Pagination-Page-Count`: Número de páginas;
+* `X-Pagination-Current-Page`: Página actual (iniciando en 1);
+* `X-Pagination-Per-Page`: Número de recursos por página;
+* `Link`: Un conjunto de enlaces de navegación permitiendo al cliente recorrer los recursos página a página.
+
+Un ejemplo se puede ver en la sección [Inicio rápido (Quick Start)](rest-quick-start.md#trying-it-out).

docs/guide-es/rest-response-formatting.md

+Dando Formato a la Respuesta
+===================
+
+Cuando se maneja una petición al API RESTful, una aplicación realiza usualmente los siguientes pasos que están relacionados con el formato de la respuesta:
+
+1. Determinar varios factores que pueden afectar al formato de la respuesta, como son el tipo de medio, lenguaje, versión, etc.
+   Este proceso es también conocido como [Negociación de contenido (content negotiation)](http://en.wikipedia.org/wiki/Content_negotiation).
+2. La conversión de objetos recursos en arrays, está descrito en la sección [Recursos (Resources)](rest-resources.md).
+   Esto es realizado por el serializador [[yii\rest\Serializer]].
+> Tip: Serializar es convertir un elemento a un formato que nos permita guardardarlo de forma permanente, de modo que posteriormente, al recuperarlo, nos de una copia igual a la del elemento antes de ser inicialmente serializado. 
+3. La conversión de arrays en cadenas con el formato determinado por el paso de negociación de contenido. Esto es realizado por  [[yii\web\ResponseFormatterInterface|response formatters]] registrado con el componente de la aplicación  [[yii\web\Response::formatters|response]].
+
+
+## Negociación de contenido (Content Negotiation) <a name="content-negotiation"></a>
+
+Yii soporta la negoiciación de contenido a través del filtro [[yii\filters\ContentNegotiator]]. La clase controladora base del API RESTful [[yii\rest\Controller]] está equipada con este filtro bajo el nombre `contentNegotiator`.
+El filtro provee tanto un formato de respuesta de negociación como una negociación de lenguaje. Por ejemplo, si la petición API RESTful contiene la siguiente cabecera,
+
+```
+Accept: application/json; q=1.0, */*; q=0.1
+```
+
+puede obtener una respuesta en formato JSON, como lo que sigue:
+
+```
+$ curl -i -H "Accept: application/json; q=1.0, */*; q=0.1" "http://localhost/users"
+
+HTTP/1.1 200 OK
+Date: Sun, 02 Mar 2014 05:31:43 GMT
+Server: Apache/2.2.26 (Unix) DAV/2 PHP/5.4.20 mod_ssl/2.2.26 OpenSSL/0.9.8y
+X-Powered-By: PHP/5.4.20
+X-Pagination-Total-Count: 1000
+X-Pagination-Page-Count: 50
+X-Pagination-Current-Page: 1
+X-Pagination-Per-Page: 20
+Link: <http://localhost/users?page=1>; rel=self,
+      <http://localhost/users?page=2>; rel=next,
+      <http://localhost/users?page=50>; rel=last
+Transfer-Encoding: chunked
+Content-Type: application/json; charset=UTF-8
+
+[
+    {
+        "id": 1,
+        ...
+    },
+    {
+        "id": 2,
+        ...
+    },
+    ...
+]
+```
+
+En la parte de atrás, antes de que sea ejecutada una acción de la controladora del API RESTful, el filtro [[yii\filters\ContentNegotiator]] comprobará en la cabecera HTTP el `Accept` de la petición y pondrá como `'json'` [[yii\web\Response::format|response format]]. Después de que la acción sea ejecutada y devuelva el recurso objeto resultante o una colección resultante,
+[[yii\rest\Serializer]] convertirá el resultado en un array. Y finalmente, [[yii\web\JsonResponseFormatter]] serializará el array en una cadena JSON incluyéndola en el cuerpo de la respuesta.
+
+Por defecto, el API RESTful soporta tanto el formato JSON como el XML. Para soportar un nuevo formato, debes configurar la propiedad [[yii\filters\ContentNegotiator::formats|formats]] del filtro `contentNegotiator`  tal y como sigue, en las clases de la controladora del API:
+
+
+```php
+use yii\web\Response;
+
+public function behaviors()
+{
+    $behaviors = parent::behaviors();
+    $behaviors['contentNegotiator']['formats']['text/html'] = Response::FORMAT_HTML;
+    return $behaviors;
+}
+```
+
+Las claves de la propiedad `formats` son los tipos MIME soportados, mientras que los valores son los nombre de formato de respuesta correspondientes, los cuales han de estar soportados en [[yii\web\Response::formatters]].
+
+
+## Serialización de Datos <a name="data-serializing"></a>
+
+Como hemos descrito antes, [[yii\rest\Serializer]] es la pieza central para convertir recursos objeto o colecciones en arrays. Reconoce objetos tanto implementando [[yii\base\ArrayableInterface]] como  [[yii\data\DataProviderInterface]]. El primer formateador es implementado principalmente para recursos objeto, mientras que el segundo para recursos collección.
+
+Puedes configurar el serializador poniendo la propiedad [[yii\rest\Controller::serializer]] con un array de configuración.
+Por ejemplo, a veces puedes querer simplificar la ayuda al trabajo de desarrollo del cliente incluyendo información de la paginación directamente en el cuerpo de la respuesta. Para hacer esto, configura la propiedad [[yii\rest\Serializer::collectionEnvelope]] como sigue:
+
+```php
+use yii\rest\ActiveController;
+
+class UserController extends ActiveController
+{
+    public $modelClass = 'app\models\User';
+    public $serializer = [
+        'class' => 'yii\rest\Serializer',
+        'collectionEnvelope' => 'items',
+    ];
+}
+```
+
+Puedes obtener la respuesta que sigue para la petición `http://localhost/users`:
+
+```
+HTTP/1.1 200 OK
+Date: Sun, 02 Mar 2014 05:31:43 GMT
+Server: Apache/2.2.26 (Unix) DAV/2 PHP/5.4.20 mod_ssl/2.2.26 OpenSSL/0.9.8y
+X-Powered-By: PHP/5.4.20
+X-Pagination-Total-Count: 1000
+X-Pagination-Page-Count: 50
+X-Pagination-Current-Page: 1
+X-Pagination-Per-Page: 20
+Link: <http://localhost/users?page=1>; rel=self,
+      <http://localhost/users?page=2>; rel=next,
+      <http://localhost/users?page=50>; rel=last
+Transfer-Encoding: chunked
+Content-Type: application/json; charset=UTF-8
+
+{
+    "items": [
+        {
+            "id": 1,
+            ...
+        },
+        {
+            "id": 2,
+            ...
+        },
+        ...
+    ],
+    "_links": {
+        "self": "http://localhost/users?page=1",
+        "next": "http://localhost/users?page=2",
+        "last": "http://localhost/users?page=50"
+    },
+    "_meta": {
+        "totalCount": 1000,
+        "pageCount": 50,
+        "currentPage": 1,
+        "perPage": 20
+    }
+}
+```

docs/guide-es/rest-routing.md

+Enrutado
+=======
+
+Con los recursos y las clases controladoras preparadas, puedes acceder a los recursos usando una URL como `http://localhost/index.php?r=user/create`, parecida a la que usas con aplicaciones Web normales.
+
+En la práctica, querrás usualmente usar URLs más bonitas y obtener ventajas de los comandos de acciones (verbos) HTTP.
+Por ejemplo, una petición `POST /users` puede permitir el acceso a la acción `user/create`.
+Esto puede realizarse fácilmente configurando el componente de la aplicación `urlManager` en la configuración tal y como sigue:
+
+```php
+'urlManager' => [
+    'enablePrettyUrl' => true,
+    'enableStrictParsing' => true,
+    'showScriptName' => false,
+    'rules' => [
+        ['class' => 'yii\rest\UrlRule', 'controller' => 'user'],
+    ],
+]
+```
+
+En comparación con la gestión de URL en las aplicaciones Web, lo nuevo de lo anterior es el uso de [[yii\rest\UrlRule]] para el enrutado de las peticiones con el API RESTful. Esta clase especial que contiene la norma para gestionar las URLs puede crear todo un conjunto de URLs hijas para mantener el enrutado y la creación de URLs para la/s especificada/s controlador/as.
+Por ejemplo, el código anterior es aproximadamente equivalente a las siguientes reglas:
+
+```php
+[
+    'PUT,PATCH users/<id>' => 'user/update',
+    'DELETE users/<id>' => 'user/delete',
+    'GET,HEAD users/<id>' => 'user/view',
+    'POST users' => 'user/create',
+    'GET,HEAD users' => 'user/index',
+    'users/<id>' => 'user/options',
+    'users' => 'user/options',
+]
+```
+
+Y los siguientes puntos finales del API son mantenidos por la siguiente regla:
+
+* `GET /users`: listado de todos los usuarios página a página;
+* `HEAD /users`: enseña ĺa información resumén del usuario listado;
+* `POST /users`: crea un nuevo usuario;
+* `GET /users/123`: devuelve los detalles del usuario 123;
+* `HEAD /users/123`: enseña la información resúmen del usuario 123;
+* `PATCH /users/123` y `PUT /users/123`: actualizan al usuario 123;
+* `DELETE /users/123`: borra el usuario 123;
+* `OPTIONS /users`: presenta las acciones finales soportadas por `/users`;
+* `OPTIONS /users/123`: presenta las acciones finales que soporta `/users/123`.
+
+Puedes configurar las opciones  `only` y `except` para explícitamente listar las acciones a soportar y cuales desabilitar, respectivamente. Por ejemplo,
+
+```php
+[
+    'class' => 'yii\rest\UrlRule',
+    'controller' => 'user',
+    'except' => ['delete', 'create', 'update'],
+],
+```
+
+También puedes configurar `patterns` o `extraPatterns` para redifinir patrones existentes o añadir nuevos patrones que soportan esta regla.
+Por ejemplo, para soportar la nueva acción `search` por `GET /users/search`, configura la opción `extraPatterns` como sigue,
+
+```php
+[
+    'class' => 'yii\rest\UrlRule',
+    'controller' => 'user',
+    'extraPatterns' => [
+        'GET search' => 'search',
+    ],
+```
+
+Queda advertido que la ID de la controladora `user` aparece finalmente en plural  tal que`users`.
+Esto es debido a que [[yii\rest\UrlRule]] pluraliza de forma automáticalos IDs de las controladoras para ser usadas en los puntos finales.
+Puedes desactivar este comportamiento poniendo a false [[yii\rest\UrlRule::pluralize]] , o si quieres usar algunos nombres especiales, debes configurar la propiedad [[yii\rest\UrlRule::controller]]. Dése cuenta que la pluralización de puntos finales del RESTful no siempre añade simplemente una "s" l final de la id de la controladora. Una controladora cuyo ID termina en "x", por ejemplo "BoxController" (con ID `box`), tiene el punto final del RESTful pluralizada  a `boxes` por [[yii\rest\UrlRule]].

docs/guide-es/rest-versioning.md

+Versionado
+==========
+
+Una buena API ha de ser *versionada*: los cambios y las nuevas características son implementadas en las nuevas versiones del API, en vez de estar continuamente modificando sólo una versión. Al contrario que en las aplicaciones Web, en las cuales tienes total control del código de ambas partes lado del cliente y lado del servidor, las APIs están destinadas a ser usadas por los clientes fuera de tu control. Por esta razón, compatibilidades hacia atrás (BC Backward compatibility) de las APIs ha de ser mantenida siempre que sea posible. Si es necesario un cambio que puede romper la BC, debes de introducirla en la nueva versión del API, e incrementar el número de versión. Los clientes que la usan pueden continuar usando la antigua versión de trabajo del API; los nuevos y actualizados clientes pueden obtener la nueva funcionalidad de la nueva versión del API.
+
+> Tip: referirse a [Semántica del versionado](http://semver.org/) para más información en el diseño del número de versión del API.
+
+Una manera común de implementar el versionado de la API es embeber el número de versión en las URLs del AP.
+Por ejemplo, `http://example.com/v1/users` se inicia por la versión 1 de la API del la parte final `/users`.
+
+Otro método de versionado de la API , la cual está ganando predominancia recientemente, es poner el número de versión en las cabeceras de la petición HTTP. Esto se suele hacer típicamente a través la cabecera `Accept` :
+
+```
+// vía parámetros
+Accept: application/json; version=v1
+// vía de el tipo de contenido del vendedor
+Accept: application/vnd.company.myapp-v1+json
+```
+
+Ambos métodos tienen sus pros y sus contras, y hay gran cantidad de debates sobre cada uno. Debajo puedes ver una estrategia práctica para el versionado de la API que es una mezcla de estos dos métodos:
+
+* Pon cada versión superior del API en un módulo separado cuya ID es el número de la versión principal. (p.e. `v1`, `v2`).
+  Naturalmente, las URLs del API pueden contener números de versión superiores.
+* Dentro de cada versión superior (y por tanto, dentro del correspondiente módulo), usa la cabecera de HTTP `Accept` para determinar el número de la menor versión y escribe código condicional para responder a la menor versión en consecuencia.
+
+Para cada módulo sirviendo una versión superior, el módulo debe incluir los recursos y la clase controladora que especifican la versión. Para mejor separar la responsabilidad del código, puedes conservar un conjunto de recursos base y clases de controladores comunes, y hacer subclases de ellas en cada uno de los módulos de versión individual. Dentro de las subclases, impementa el código concreto como es `Model::fields()`.
+
+Tu código puede estar organizado como lo que sigue:
+
+```
+api/
+    common/
+        controllers/
+            UserController.php
+            PostController.php
+        models/
+            User.php
+            Post.php
+    modules/
+        v1/
+            controllers/
+                UserController.php
+                PostController.php
+            models/
+                User.php
+                Post.php
+        v2/
+            controllers/
+                UserController.php
+                PostController.php
+            models/
+                User.php
+                Post.php
+```
+
+La configuración de su aplicación puede tener este aspecto:
+
+```php
+return [
+    'modules' => [
+        'v1' => [
+            'basePath' => '@app/modules/v1',
+            'controllerNamespace' => 'app\modules\v1\controllers',
+        ],
+        'v2' => [
+            'basePath' => '@app/modules/v2',
+            'controllerNamespace' => 'app\modules\v2\controllers',
+        ],
+    ],
+    'components' => [
+        'urlManager' => [
+            'enablePrettyUrl' => true,
+            'enableStrictParsing' => true,
+            'showScriptName' => false,
+            'rules' => [
+                ['class' => 'yii\rest\UrlRule', 'controller' => ['v1/user', 'v1/post']],
+                ['class' => 'yii\rest\UrlRule', 'controller' => ['v2/user', 'v2/post']],
+            ],
+        ],
+    ],
+];
+```
+
+Como consecuencia de el anterior código, `http://example.com/v1/users` puede devolver la lista de usuarios de la versión 1, mientras
+`http://example.com/v2/users` puede devolver la versión 2 de los usuarios.
+
+Gracias a los módulos, el código de las diferentes principales versiónes puede ser aislado. Pero, los módulos, hacen posible reusar el código a través de los módulos vía clases base comunes y otros recursos compartidos.
+
+Para traficar con los números de versión menores, puede obtener las ventajas de el contenido de las capacidades de las conductas de negociación provistas por el [[yii\filters\ContentNegotiator|contentNegotiator]]. La conducta `contentNegotiator` puede poner la propiead [[yii\web\Response::acceptParams]] cuando determina cuál tipo de contenido a soportar.
+
+Por ejemplo, si una peticiónes enviada con la cabecera HTTP `Accept: application/json; version=v1`, entonces la conducta de negociación, [[yii\web\Response::acceptParams]] puede contener el valor `['version' => 'v1']`.
+
+Basado en la información de versión contenida en `acceptParams`, puedes escribir código condicional en lugares como acciones, clases de recursos, serializadores, etc. para proveer la funcionalidad apropiada.
+
+Desde la menor versión, por definición, es necesario mantener la compatibilidad hacia atrás, con suerte no tendrás demasiadas versiones a comporbar en tu código. De otra manera, probablemente puede ocurrir que necesites crear una versión principal.

docs/guide-es/tutorial-core-validators.md

+Validadores del núcleo
+======================
+
+Yii provee en el núcleo un conjunto de validadores de uso común, que se pueden encontrar principalmente bajo el espacio de nombres (namespace) `yii\validators`.
+En vez de utilizar interminables nombres de clases para los validadores, puedes usar *alias* para especificar el uso de esos validadores del núcleo. Por ejemplo, puedes usar el alias `required` para referirte a la clase [[yii\validators\RequiredValidator]] :
+
+```php
+public function rules()
+{
+    return [
+        [['email', 'password'], 'required'],
+    ];
+}
+```
+
+La propiedad [[yii\validators\Validator::builtInValidators]] declara todos los aliases de los validadores soportados.
+
+A continuación, vamos a describir el uso principal y las propiedades de cada validador del núcleo.
+
+
+## [[yii\validators\BooleanValidator|boolean]] <a name="boolean"></a>
+
+```php
+[
+    // comprueba si "selected" es 0 o 1, sin mirar el tipo de dato
+    ['selected', 'boolean'],
+
+    // comprueba si "deleted" es del tipo booleano, alguno entre true o false
+    ['deleted', 'boolean', 'trueValue' => true, 'falseValue' => false, 'strict' => true],
+]
+```
+
+Este validador comprueba si el valor de la entrada (input) es booleano.
+
+- `trueValue`: El valor representando *true*. Valor por defecto a `'1'`.
+- `falseValue`: El valor representando *false*. Valor por defecto a `'0'`.
+- `strict`: Si el tipo del valor de la entrada (input) debe corresponder con `trueValue` y `falseValue`. Valor por defecto a `false`.
+
+
+> Nota: Ya que los datos enviados con la entrada, vía formularios HTML,son todos cadenas (strings), usted debe normalmente dejar la propiedad  [[yii\validators\BooleanValidator::strict|strict]] a false.
+
+
+## [[yii\captcha\CaptchaValidator|captcha]] <a name="captcha"></a>
+
+```php
+[
+    ['verificationCode', 'captcha'],
+]
+```
+
+Este validador es usualmente usado junto con [[yii\captcha\CaptchaAction]] y [[yii\captcha\Captcha]] para asegurarse que una entrada es la misma que lo es el código de verificación que enseña el widget [[yii\captcha\Captcha|CAPTCHA]].
+
+- `caseSensitive`: cuando la comparación del código de verificación depende de que sean mayúsculas y minúsculas (case sensitive). Por defecto a false.
+- `captchaAction`: la [ruta](structure-controllers.md#routes) correspondiente a
+  [[yii\captcha\CaptchaAction|CAPTCHA action]] que representa (render) la imagen CAPTCHA. Por defecto`'site/captcha'`.
+- `skipOnEmpty`: cuando la validación puede saltarse si la entrada está vacía. Por defecto a false, lo caul permite que la entrada sea necesaria (required).
+  
+
+## [[yii\validators\CompareValidator|compare]] <a name="compare"></a>
+
+```php
+[
+    // valida si el valor del atributo "password" es igual al  "password_repeat"
+    ['password', 'compare'],
+
+    // valida si la edad es mayor que o igual que 30
+    ['age', 'compare', 'compareValue' => 30, 'operator' => '>='],
+]
+```
+
+Este validador compara el valor especificado por la entrada con otro valor y, se asegura si su relación es la especificada por la propiedad `operator`.
+
+- `compareAttribute`: El nombre del valor del atributo con el cual debe compararse. Cuando el validador está siendo usado para validar un atributo, el valor por defecto de esta propiedad debe de ser el nombre de el atributo con el sufijo `_repeat`. Por  ejemplo, si el atributo a ser validado es `password`, entonces esta propiedad contiene por defecto `password_repeat`.
+- `compareValue`: un valor constante con el que el valor de entrada debe ser comparado. Cuando ambos, esta propiedad y `compareAttribute` son especificados, esta preferencia tiene precedencia.
+- `operator`: el operador de comparación. Por defecto vale `==`, permitiendo comprobar si el valor de entrada es igual al de `compareAttribute` o `compareValue`. Los siguientes operadores son soportados:
+     * `==`: comprueba si dos valores son iguales. La comparación se realiza en modo no estricto.
+     * `===`: comprueba si dos valores son iguales. La comparación se realiza en modo estricto.
+     * `!=`: comprueba si dos valores NO son iguales. La comparación se realiza en modo no estricto.
+     * `!==`: comprueba si dos valores NO son iguales. La comparación se realiza en modo estricto.
+     * `>`: comprueba si el valor siendo validado es mayor que el valor con el que se compara.
+     * `>=`: comprueba si el valor siendo validado es mayor o igual que el valor con el que se compara
+     * `<`: comprueba si el valor siendo validado es menor que el valor con el que se compara
+     * `<=`: comprueba si el valor siendo validado es menor o igual que el valor con el que se compara
+
+
+## [[yii\validators\DateValidator|date]] <a name="date"></a>
+
+```php
+[
+    [['from', 'to'], 'date'],
+]
+```
+
+Este validador comprueba si el valor de entrada es una fecha, tiempo or fecha/tiempo y tiempo en el formato correcto.
+Opcionalmente, puede convertir el valor de entrada en una fecha/tiempo UNIX y almacenarla en un atributo especificado vía [[yii\validators\DateValidator::timestampAttribute|timestampAttribute]].
+
+- `format`: el formato fecha/tiempo en el que debe estar el valor a ser validado. 
+   Esto tiene que ser un patrón fecha/tiempo descrito en [manual ICU](http://userguide.icu-project.org/formatparse/datetime#TOC-Date-Time-Format-Syntax).
+   Alternativamente tiene que ser una cadena con el prefijo `php:` representando un formato que ha de ser reconocido por la clase `Datetime` de PHP. Por favor, refiérase a <http://php.net/manual/en/datetime.createfromformat.php> sobre los formatos soportados.
+   Si no tiene ningún valor, ha de coger el valor de `Yii::$app->formatter->dateFormat`.
+- `timestampAttribute`: el nombre del atributo al cual este validador puede asignar el fecha/hora UNIX convertida desde la entrada fecha/hora.
+
+
+## [[yii\validators\DefaultValueValidator|default]] <a name="default"></a>
+
+```php
+[
+    // pone el valor de "age" a null si está vacío
+    ['age', 'default', 'value' => null],
+
+    // pone el valor de "country" a "USA" si está vacío
+    ['country', 'default', 'value' => 'USA'],
+
+    // asigna "from" y "to" con una fecha 3 días y 6 días a partir de hoy, si está vacía
+    [['from', 'to'], 'default', 'value' => function ($model, $attribute) {
+        return date('Y-m-d', strtotime($attribute === 'to' ? '+3 days' : '+6 days'));
+    }],
+]
+```
+
+Este validador no valida datos. En cambio, asigna un valor por defecto a los atributos siendo validados, si los atributos están vacíos.
+
+- `value`: el valor por defecto o un elemento llamable de PHP que devuelva el valor por defecto, el cual, va a ser asignado a los atributos siendo validados, si estos están vacíos. La signatura de la función PHP tiene que ser como sigue,
+
+```php
+function foo($model, $attribute) {
+    // ... calcula $value ...
+    return $value;
+}
+```
+
+> Info: Cómo determinar si un valor está vacío o no, es un tópico separado cubierto en la sección [Valores Vacíos](input-validation.md#handling-empty-inputs) .
+
+
+## [[yii\validators\NumberValidator|double]] <a name="double"></a>
+
+```php
+[
+    // comprueba si  "salary" es un número de tipo doble
+    ['salary', 'double'],
+]
+```
+
+Esta validador comprueba si el valor de entrada es un número de tipo doble. Es equivalente a el validador [Número](#number) .
+
+- `max`: el valor límite superior (incluido) de el valor. Si no tiene valor, significa que no se comprueba el valor superior.
+- `min`: el valor límite inferior (incluido) de el valor. Si no tiene valor, significa que no se comprueba el valor inferior.
+
+
+## [[yii\validators\EmailValidator|email]] <a name="email"></a>
+
+```php
+[
+    // comprueba si "email" es una dirección válida de email
+    ['email', 'email'],
+]
+```
+
+Este validador comprueba si el valor de entrada es una dirección válida de email.
+
+- `allowName`: indica cuando permitir el nombre en la dirección de email (p.e. `John Smith <john.smith@example.com>`). Por defecto a false.
+- `checkDNS`, comprobar cuando el dominio del email existe y tiene cualquier registro  A o MX.
+  Es necesario ser consciente que esta comprobación puede fallar debido a problemas temporales de  DNS, incluso si el la dirección es válida actualmente.
+  Por defecto a false.
+- `enableIDN`, indica cuando el proceso de validación debe tener en cuenta el informe de IDN (internationalized domain names).
+  Por defecto a false. Dese cuenta que para poder usar la validación de IDN has de instalar y activar la extensión de PHP `intl`,  o será lanzada una excepción.
+
+
+## [[yii\validators\ExistValidator|exist]] <a name="exist"></a>
+
+```php
+[
+    // a1 necesita que exista una columna con el atributo "a1" 
+    ['a1', 'exist'],
+
+    // a1 necesita existir,pero su valor puede usar a2 para comprobar la existencia
+    ['a1', 'exist', 'targetAttribute' => 'a2'],
+
+    // a1 y a2 necesitan existir ambos, y ambos pueden recibir un mensaje de error
+    [['a1', 'a2'], 'exist', 'targetAttribute' => ['a1', 'a2']],
+
+    // a1 y a2 necesitan existir ambos, sólo a1 puede recibir el mensaje de error
+    ['a1', 'exist', 'targetAttribute' => ['a1', 'a2']],
+
+    // a1 necesita existir comprobando la existencia ambos a2 y a3 (usando el valor a1)
+    ['a1', 'exist', 'targetAttribute' => ['a2', 'a1' => 'a3']],
+
+    // a1 necesita existir. Si a1 es un array, cada elemento de él tiene que existir.
+    ['a1', 'exist', 'allowArray' => true],
+]
+```
+
+Este validador comprueba si el valor de entrada puede ser encontrado en una columna de una tabla. Sólo funciona con los atributos del modelo [Registro Activo (Active Record)](db-active-record.md). Soporta validación tanto con una simple columna o múltiples columnas.
+
+- `targetClass`: el nombre de la clase [Registro Activo (Active Record)](db-active-record.md) debe de ser usada para mirar por el valor de entrada siendo validado. Si no tiene valor, la clase del modelo actualmente siendo validado puede ser usada.
+- `targetAttribute`: el nombre del atributo en `targetClass` que debe de ser usado para validar la existencia del valor de entrada. Si no tiene valor, puede usar el nombra del atributoactualmente siendo validado.
+  Puede usar una array para validar la existencia de múltiples columnas al mismo tiempo. El array de valores son los atributos que pueden ser usados para validar la existencia, mientras que las claves del array son los atributos a ser validados. Si la clave y el valor son los mismos, solo en ese momento puedes especificar el valor.
+- `filter`: filtro adicional a aplicar a la consulta de la base de datos usado para comprobar la existencia de una valor de entrada.
+  Esto puede ser una cadena o un array representando la condición de la consulta (referirse a [[yii\db\Query::where()]] sobre el formato de la condición de consulta), o una función anónima con la signatura `function ($query)`, donde `$query` es el objeto [[yii\db\Query|Query]] que puedes modificar en la función.
+- `allowArray`: indica cuando permitir que el valor de entrada sea un array. Por defecto a false.Si la propiedad es true y la entrada es un array, cada elemento del array debe existir en la columna destino. Nota que esta propiedad no puede ser true si estás validando, por el contrario, múltiple columnas poniendo el valor del atributo `targetAttribute` como que es un array.
+
+
+## [[yii\validators\FileValidator|file]] <a name="file"></a>
+
+```php
+[
+    // comprueba si "primaryImage" es un fichero mde imagen en formato PNG, JPG o GIF.
+    // el tamaño del fichero ha de ser menor de 1MB
+    ['primaryImage', 'file', 'extensions' => ['png', 'jpg', 'gif'], 'maxSize' => 1024*1024*1024],
+]
+```
+
+Este validador comprueba que el fichero subido es el adecuado.
+
+- `extensions`: una lista de extensiones de ficheros que pueden ser subidos. Esto puede ser tanto un array o una cadena conteniendo nombres de extensiones de ficheros separados por un espacio o coma (p.e. "gif, jpg").
+  Los nombres de las extensiones no diferencian mayúsculas de minúsculas (case-insensitive). Por defecto a null, permitiendo todas los nombres de extensiones de fichero.
+- `mimeTypes`: una lista de tipos de ficheros MIME  que están permitidos subir. Esto puede ser tanto un array como una cadena conteniendo tipos de fichero MIME separados por un espacio o una coma (p.e. "image/jpeg, image/png").
+  Los tipos Mime no diferencian mayúsculas de minúsculas (case-insensitive). Por defecto a null, permitiendo todos los tipos MIME.
+- `minSize`: el número de bytes mínimo requerido para el fichero subido. El tamaño del fichero ha de ser superior a este valor. Por defecto a null, lo que significa sin límite inferior. 
+- `maxSize`: El número máximo de bytes del fichero a subir. El tamaño del fichero ha de ser inferior a este valor. Por defecto a null, significando no tener límite superior.
+- `maxFiles`: el máximo número de ficheros que determinado atributo puede manejar. Por defecto a 1, lo que significa que la entrada debe de ser sólo un fichero. Si es mayor que 1, entonces la entrada tiene que ser un array conteniendo como máximo el número `maxFiles` de elementos que representan los ficheros a subir.
+- `checkExtensionByMimeType`: cuando comprobar la extensión del fichero por el tipo  MIME. Si la extensión producida por la comprobación del tipo MIME difiere la extensión del fichero subido, el fichero será considerado como no válido. Por defecto a true, significando que realiza este tipo de comprobación.
+
+`FileValidator` es usado con [[yii\web\UploadedFile]]. Por favor, refiérase a la sección [Subida de ficheros](input-file-upload.md) para una completa cobertura sobre la subida de ficheros y llevar a cabo la validación de los ficheros subidos.
+
+
+## [[yii\validators\FilterValidator|filter]] <a name="filter"></a>
+
+```php
+[
+    // recorta (trim) las entradas "username" y "email"
+    [['username', 'email'], 'filter', 'filter' => 'trim', 'skipOnArray' => true],
+
+    // normaliza la entrada de  "phone"
+    ['phone', 'filter', 'filter' => function ($value) {
+        // normaliza la entrada del teléfono aquí
+        return $value;
+    }],
+]
+```
+
+Este validador no valida datos. En su lugar, aplica un filtro sobre el valor de entrada y le asigna de nuevo el atributo siendo validado.
+
+- `filter`: una retrollamada (callback) de PHP que define un filtro. Tiene que ser un nombre de función global, una función anónima, etc.
+  La forma de la función ha de ser `function ($value) { return $newValue; }`. Tiene que contener un valor esta propiedad.
+- `skipOnArray`: cuando evitar el filtro si el valor de la entrada es un array. Por defecto a false.
+  A tener en cuenta que si el filtro no puede manejar una entrada de un array, debes poner esta propiedad a true. En otro caso algún error PHP puede ocurrir.
+
+> Consejo (Tip): Si quieres recortar los valores de entrada, puedes usar directamente el validador [Recorte (trim)](#trim).
+
+
+## [[yii\validators\ImageValidator|image]] <a name="image"></a>
+
+```php
+[
+    // comprueba si "primaryImage"  es una imágen vaĺida con el tamaño adecuado
+    ['primaryImage', 'image', 'extensions' => 'png, jpg',
+        'minWidth' => 100, 'maxWidth' => 1000,
+        'minHeight' => 100, 'maxHeight' => 1000,
+    ],
+]
+```
+
+Este validador comprueba si el valor de entrada representa un fichero de imagen válido. Extiende al validador [Fichero (file)](#file) y, por lo tanto, hereda todas sus propiedades. Además, soporta las siguientes propiedades adicionales específicas para la validación de imágenes:
+
+- `minWidth`: el mínimo ancho de la imagen. Por defecto a null, indicando que no hay límite inferior.
+- `maxWidth`: el máximo ancho de la imagen. Por defecto a null, indicando que no hay límite superior.
+- `minHeight`: el mínimo alto de la imagen. Por defecto a null, indicando que no hay límite inferior.
+- `maxHeight`: el máximo alto de la imagen. Por defecto a null, indicando que no hay límite superior.
+
+
+## [[yii\validators\RangeValidator|in]] <a name="in"></a>
+
+```php
+[
+    // comprueba si "level" es 1, 2 o 3
+    ['level', 'in', 'range' => [1, 2, 3]],
+]
+```
+
+Este validador comprueba si el valor de entrada puede encontrarse entre determinada lista de valores.
+
+- `range`: una lista de determinados valores dentro de los cuales el valor de entrada debe de ser mirado.
+- `strict`: cuando la comparación entre el valor de entrada y los valores determinados debe de ser estricta (ambos el tipo y el valor han de ser iguales). Por defecto a false.
+- `not`: cuando el resultado de la validación debe de ser invertido. Por defecto a false. Cuando esta propiedad está a true, el validador comprueba que el valor de entrada NO ESTÁ en la determinada lista de valores.
+- `allowArray`: si se permite que el valor de entrada sea un array. Cuando es true y el valor de entrada es un array, cada elemento en el array debe de ser encontrado en la lista de valores determinada,o la validación fallará.
+
+
+## [[yii\validators\NumberValidator|integer]] <a name="integer"></a>
+
+```php
+[
+    // comrpueba si "age" es un entero
+    ['age', 'integer'],
+]
+```
+
+Esta validador comprueba si el valor de entrada es un entero.
+
+- `max`: el valor superior  (incluido) . Si no tiene valor, significa que el validador no comprueba el límite superior.
+- `min`: el valor inferior (incluido). Si no tiene valor, significa que el validador no comprueba el límite inferior.
+
+
+## [[yii\validators\RegularExpressionValidator|match]] <a name="match"></a>
+
+```php
+[
+    // comprueba si "username" comienza con una letra y contiene solamente caracteres en sus palabras
+    ['username', 'match', 'pattern' => '/^[a-z]\w*$/i']
+]
+```
+
+Este validador comprueba si el valor de entrada coincide con la expresión regular especificada.
+
+- `pattern`: la expresión regular conla que el valor de entrada debe coincidir. Esta propiedad no puede estar vacía, o se lanzará una excepción.
+- `not`: indica cuando invertir el resultado de la validación. Por defecto a false, significando que la validación es exitosa solamente si el valor de entrada coincide con el patrón. Si esta propiedad está a true, la validación es exitosa solamente si el valor de entrada NO coincide con el patrón.
+
+
+## [[yii\validators\NumberValidator|number]] <a name="number"></a>
+
+```php
+[
+    // comprueba si "salary" es un número
+    ['salary', 'number'],
+]
+```
+
+Este validador comprueba si el valor de entrada es un número. Es equivalente al validador [Doble precisión (double)](#double).
+
+- `max`: el valor superior límite (incluido) . Si no tiene valor, significa que el validador no comprueba el valor límite superior.
+- `min`: el valor inferior límite (incluido) . Si no tiene valor, significa que el validador no comprueba el valor límite inferior.
+
+
+## [[yii\validators\RequiredValidator|required]] <a name="required"></a>
+
+```php
+[
+    // comprueba si ambos "username" y "password" no están vacíos
+    [['username', 'password'], 'required'],
+]
+```
+
+El validador comprueba si el valor de entrada es provisto y no está vacío.
+
+- `requiredValue`: el valor deseado que la entrada debería tener. Si no tiene valor, significa que la entrada no puede estar vacía.
+- `strict`: indica como comprobar los tipos de los datos al validar un valor. Por defecto a false.
+  Cuando `requiredValue` no tiene valor, si esta propiedad es true, el validador comprueba si el valor de entrada no es estrictamente null; si la propiedad es false, el validador puede usar una regla suelta para determinar si el valor está vacío o no.
+  Cuando `requiredValue` tiene valor, la comparación entre la entrada y  `requiredValue` comprobará tambien los tipos de los datos si esta propiedad es true.
+
+> Info: Como determinar si un valor está vacío o no es un tópico separado cubierto en la sección [Valores vacíos](input-validation.md#handling-empty-inputs).
+
+
+## [[yii\validators\SafeValidator|safe]] <a name="safe"></a>
+
+```php
+[
+    // marca  "description" como un atributo seguro
+    ['description', 'safe'],
+]
+```
+
+Este validador no realiza validación de datos. En lugar de ello, es usado para marcar un atributo como seguro [atributos seguros](structure-models.md#safe-attributes).
+
+
+## [[yii\validators\StringValidator|string]] <a name="string"></a>
+
+```php
+[
+    // comprueba si "username" es una cadena cuya longitud está entre 4 Y 24
+    ['username', 'string', 'length' => [4, 24]],
+]
+```
+
+Este validador comprueba si el valor de entrada es una cadena válida con determinada longitud.
+
+- `length`: especifica la longitud límite de la cadena de entrada a validar. Esto tiene que ser especificado del las siguientes formas:
+     * un entero: la longitud exacta que la cadena debe de tener;
+     * un array de un elemento: la longitud mínima de la cadena de entrada (p.e.`[8]`). Esto puede sobre escribir `min`.
+     * un array de dos elementos: las longitudes mínima y mmáxima de la cadena de entrada (p.e. `[8, 128]`).
+     Esto sobreescribe ambos valores de `min` y `max`.
+- `min`: el mínimo valor de longitud de la cadena de entrada. Si no tiene valor, significa que no hay límite para longitud mínima.
+- `max`: el máximo valor de longitud de la cadena de entrada. Si no tiene valor, significa que no hay límite para longitud máxima.
+- `encoding`: la codificación de la cadena de entrada a ser validada. Si no tiene valor, usará el valor de la aplicación [[yii\base\Application::charset|charset]]  que por defecto es `UTF-8`.
+
+
+## [[yii\validators\FilterValidator|trim]] <a name="trim"></a>
+
+```php
+[
+    // recorta (trim) los espacios en blanco que rodean a "username" y "email"
+    [['username', 'email'], 'trim'],
+]
+```
+
+Este validador no realiza validación de datos. En cambio, recorta los espacios que rodean el valor de entrada. Nota que si el valor de entrada es un array, se ignorará este validador.
+
+
+## [[yii\validators\UniqueValidator|unique]] <a name="unique"></a>
+
+```php
+[
+    // a1 necesita ser único en la columna representada por el atributo "a1"
+    ['a1', 'unique'],
+
+    // a1 necesita ser único, pero la columna a2 puede ser usado para comprobar la unicidad del valor a1
+    ['a1', 'unique', 'targetAttribute' => 'a2'],
+
+    // a1 y a2 necesitan ambos ser únicos, y ambospueden recibir el mensaje de error
+    [['a1', 'a2'], 'unique', 'targetAttribute' => ['a1', 'a2']],
+
+    // a1 y a2 necesitan ser unicos ambos, solamente uno recibirá el mensaje de error
+    ['a1', 'unique', 'targetAttribute' => ['a1', 'a2']],
+
+    // a1 necesita ser único comprobando la unicidad de ambos a2 y a3 (usando el valor)
+    ['a1', 'unique', 'targetAttribute' => ['a2', 'a1' => 'a3']],
+]
+```
+
+Este validador comprueba si el valor de entrada es único en una columna de una tabla. Solo funciona con los atributos del modelo [Registro Activo (Active Record)](db-active-record.md). Soporta validación contra cualquiera de los casos, una columna o múltiples columnas.
+
+- `targetClass`: el nombre de la clase [Registro Activo (Active Record)](db-active-record.md) que debe de ser usada para mirar por el valor de entrada que está siendo validado. Si no tiene valor, la clase del modelo actualmente validado será usada.
+- `targetAttribute`: el nombre de el atributo en `targetClass`que debe de ser usado para validar la unicidad de el valor de entrada. Si no tiene valor, puede usar el nombre del atributo actualmente siendo validado.
+  Puedes usar un array para validar la unicidad de múltiples columnas al mismo tiempo. Los valores del array son atributos que pueden ser usados para validar la unicidad, mientras que las claves del array son los atributos que cuyos valores van a ser validados. Si la clave y el valor son el mismo, entonces puedes especificar el valor.
+- `filter`: filtro adicional puede ser aplicado a la consulta de la base de datos usado para comprobar la unicidad del valor de entrada.
+  Esto puede ser una cadena o un array representando la condición adicional a la consulta (Referirse a [[yii\db\Query::where()]] para el formato de la condición de la consulta), o una función anónima de la forma  `function ($query)`, donde `$query` es el objeto [[yii\db\Query|Query]] que puedes modificar en la función.
+
+
+## [[yii\validators\UrlValidator|url]] <a name="url"></a>
+
+```php
+[
+    // comprueba si "website" es una URL válida. Prefija con "http://" al atributo  "website"
+    // si no tiene un esquema URI
+    ['website', 'url', 'defaultScheme' => 'http'],
+]
+```
+
+Este validador comprueba si el valor de entrada es una URL válida.
+
+- `validSchemes`: un array especificando el esquema URI que debe ser considerado válido. Por defecto contiene `['http', 'https']`, significando que ambas URLS `http` y `https` son consideradas válidas.
+- `defaultScheme`: el esquema de URI a poner como prefijo a la entrada si no tiene la parte del esquema.
+  Por defecto a null, significando que no modifica el valor de entrada.
+- `enableIDN`: Si el validador debe formar parte del registro IDN (internationalized domain names).
+  Por defecto a false. Nota que para usar la validación IDN tienes que instalar y activar la extensión PHP `intl`, en otro caso una excepción será lanzada.
+

docs/guide-es/tutorial-yii-integration.md

+Trabajando con código de terceros
+=================================
+
+De tiempo en tiempo, puede necesitar usar algún código de terceros en sus aplicaciones Yii. O puedes querer usar Yii como una librería en otros sistemas de terceros. En esta sección, te enseñaremos cómo conseguir estos objetivos.
+
+
+## Usando librerías de terceros en Yii <a name="using-libs-in-yii"></a>
+
+Para usar una librería en una aplicación Yii, primeramente debes de asegurarte que las clases een la librería son incluidas adecuadamente o pueden ser cargadas de forma automática.
+
+
+### Usando Paquetes de Composer <a name="using-composer-packages"></a>
+
+Muchas librerías de terceros son liberadas en términos de paquetes [Composer](https://getcomposer.org/).
+Puedes instalar este tipo de librerias siguiendo dos sencillos pasos:
+
+1. modificar el fichero `composer.json` de tu aplicación y especificar que paquetes Composer quieres instalar.
+2. ejecuta `composer install` para instalar los paquetes específicados.
+
+Las clases en los paquetes Composer instalados pueden ser autocargados usando el cargador automatizado de Composer autoloader. Asegúrate que el fichero [script de entrada](structure-entry-scripts.md) de tu aplicación contiene las siguientes líneas para instalar el cargador automático de Composer:
+
+```php
+// instalar el cargador automático de  Composer
+require(__DIR__ . '/../vendor/autoload.php');
+
+// incluir rl fichero de la clase Yii
+require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
+```
+
+
+### Usando librerías Descargadas <a name="using-downloaded-libs"></a>
+
+Si la librería no es liberada como un paquete de Composer, debes de seguir sus instrucciones de instalación para instalarla.
+En muchos casos, puedes necesitar descargar manualmente el fichero de la versión y desempaquetarlo en el directorio `BasePath/vendor` , donde `BasePath` representa el [camino base (base path)](structure-applications.md#basePath) de tu aplicación.
+
+Si la librería lleva su propio cargador automático (autoloader), puedes instalarlo en [script de entrada](structure-entry-scripts.md) de tu aplicación. Es recomendable que la instalación se  termine antes de incluir el fichero `Yii.php` de forma que el cargador automático tenga precedencia al cargar de forma automática las clases.
+
+Si la librería no provee un cargador automático de clases, pero la denominación de sus clases sigue el [PSR-4](http://www.php-fig.org/psr/psr-4/), puedes usar el cargador automático de Yii para cargar de forma automática las clases. Todo lo que necesitas es declarar un [alias raiz](concept-aliases.md#defining-aliases) para cada espacio de nombres (namespace) raiz usado en sus clases. Por ejemplo, asume que has instalado una librería en el directorio `vendor/foo/bar`, y que las clases de la librería están bajo el espacio de nombres raiz `xyz`. Puedes incluir el siguiente código en la configuración de tu aplicación:
+
+```php
+[
+    'aliases' => [
+        '@xyz' => '@vendor/foo/bar',
+    ],
+]
+```
+
+Si ninguno de lo anterior es el caso, estaría bien que la librería dependa del camino de inclusión (include path) de configuración de PHP para localizar correctamente e incluir los ficheros  de las clases. Simplemente siguiendo estas instrucciones de cómo configurar el camino de inclusión de PHP.
+
+En el caso más grave en el que la librería necesite incluir cada uno de sus ficheros de clases, puedes usar el siguiente método para incluir las clases según se pidan:
+
+* Identificar que clases contiene la librería.
+* Listar las clases y el camino a los ficheros correspondientes en `Yii::$classMap`  en el script de entrada [script de entrada](structure-entry-scripts.md) de la aplicación. Por ejemplo,
+```php
+Yii::$classMap['Class1'] = 'path/to/Class1.php';
+Yii::$classMap['Class2'] = 'path/to/Class2.php';
+```
+
+
+## Usando Yii en Sistemas de Terceros <a name="using-yii-in-others"></a>
+
+Debido a que Yii provee muchas posibilidades excelentes, a veces puedes querer usar alguna de sus características para permitir el desarrollo o mejora de sistemas de terceros, como es WordPress, Joomla, o aplicaciones desarrolladas usando otros frameworks de PHP. Por ejemplo, puedes queres usar la clase [[yii\helpers\ArrayHelper]]  o usar la característica [Active Record](db-active-record.md) en un sistema de terceros. Para lograr este objetivo, principalmente necesitas realizar dos pasos: instalar Yii , e iniciar  Yii.
+
+Si el sistema de terceros usa Composer para manejar sus dependencias, simplemente ejecuta estos comandos para instalar Yii:
+
+```
+composer require "yiisoft/yii2:*"
+composer install
+```
+
+En otro caso, puedes [descargar](http://www.yiiframework.com/download/) el fichero de la edición de Yii y desempaquetarla en el directorio `BasePath/vendor`.
+
+Después, debes de modificar el script de entrada de sistema de terceros para incluir el siguiente código al principio:
+
+```php
+require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
+
+$yiiConfig = require(__DIR__ . '/../config/yii/web.php');
+new yii\web\Application($yiiConfig); // No ejecutes run() aquí
+```
+
+Como puedes ver, el código anterior es muy similar al que puedes ver en [script de entrada](structure-entry-scripts.md) de una aplicación típica. La única diferencia es que después de que se crea la instancia de la aplicación, el método `run()` no es llamado. Esto es así porque llamando a `run()`, Yii se haría cargo del control del flujo de trabajo del manejo de las peticiones, lo cual no es necesario en este caso por estar ya es manejado por la aplicación existente.
+
+Como en una aplicación Yii, debes configurar la instancia de la aplicación basándose en el entorno que se está ejecutando del sistema de terceros. Por ejemplo, para usar la característica [Active Record](db-active-record.md) , necesitas configurar `db` [componente de la aplicación](structure-application-components.md) con los parámetros de la conexión de base de datos usados por el sistema de terceros.
+
+Ahora puedes usar muchas características provistas por Yii. Por ejemplo, puedes crear clases Active Record y usarlas para trabajar con bases de datos.
+
+
+## Usando Yii 2 con Yii 1 <a name="using-both-yii2-yii1"></a>
+
+Si estaba usando Yii 1 previamente, es como si tuvieras una aplicación Yii 1 funcionando. En vez de reescribir toda la aplicación en Yii 2, puedes solamente mejorarla usando alguna de las características sólo disponibles en Yii 2.
+
+Esto se puede lograr tal y como se describe abajo.
+
+> Nota: Yii 2 requiere PHP 5.4 o superior. Debes de estar seguro que tanto tu servidor como la aplicación existente lo soportan.
+
+Primero, instala Yii 2 en tu aplicación siguiendo las instrucciones descritas en la [última subsección](#using-yii-in-others).
+
+Segundo,modifica el script de entrada de la aplicación como sigue,
+
+```php
+// incluir la clase Yii personalizada descrita debajo
+require(__DIR__ . '/../components/Yii.php');
+
+// configuración para la aplicación Yii 2
+$yii2Config = require(__DIR__ . '/../config/yii2/web.php');
+new yii\web\Application($yii2Config); // No llamar a run()
+
+// configuración para la aplicación Yii 1
+$yii1Config = require(__DIR__ . '/../config/yii1/main.php');
+Yii::createWebApplication($yii1Config)->run();
+```
+
+Debido a que ambos Yii 1 y Yii 2 tiene la clase `Yii` , debes crear una versión personalizada para combinarlas.
+
+El código anterior incluye el fichero con la clase `Yii` personalizada, que tiene que ser creada como sigue.
+
+```php
+$yii2path = '/path/to/yii2';
+require($yii2path . '/BaseYii.php'); // Yii 2.x
+
+$yii1path = '/path/to/yii1';
+require($yii1path . '/YiiBase.php'); // Yii 1.x
+
+class Yii extends \yii\BaseYii
+{
+    // copy-paste the code from YiiBase (1.x) here
+}
+
+Yii::$classMap = include($yii2path . '/classes.php');
+// registrar el autoloader de Yii2 autoloader via Yii1
+Yii::registerAutoloader(['Yii', 'autoload']);
+// crear el contenedor de inyección de dependencia
+Yii::$container = new yii\di\Container;
+```
+
+¡Esto es todo!. Ahora, en cualquier parte de tu código, puedes usar `Yii::$app` para acceder a la instancia de la aplicación de Yii 2, mientras `Yii::app()` proporciona la instancia de la aplicación de  Yii 1 :
+
+```php
+echo get_class(Yii::app()); // genera 'CWebApplication'
+echo get_class(Yii::$app);  // genera 'yii\web\Application'
+```

docs/guide-es/widget-bootstrap.md

+Widgets de Bootstrap 
+====================
+
+> Nota: Esta sección está bajo desarrollo.
+
+Yii incluye soporta las marcas y componentes del framework [Bootstrap 3](http://getbootstrap.com/) (también conocido como "Twitter Bootstrap"). Bootstrap es un excelente, adaptable framework que puede aumentar la velocidad de desarrollo de los procesos del lado del cliente.
+
+El núcleo de Bootstrap está represntado en dos partes:
+
+- Elementos básicos de CSS, como son un sistema de diseño en formato cuadrícula , tipografía, clases de ayuda (helpers), y utilidades adapatables(responsive).
+
+- Componentes preparados para su uso, tales como formularios, menús, paginación, cajas modales, pestañas, etc
+
+Elementos básicos
+------
+
+Yii no hace uso de elementos básicos de boostrap en el código PHP ya que HTML es muy simple por sí mismo, en este caso. Puedes encontrar detalle del uso de estos elementos básicos en [sitio web de la documentación de bootstrap](http://getbootstrap.com/css/). Aún así Yii provee una manera conveniente de incluir los elementos básicos de los recursos de bootstrap en tus páginas con una simple línea añadida a `AppAsset.php` localizada en tu directorio `@app/assets` :
+
+```php
+public $depends = [
+    'yii\web\YiiAsset',
+    'yii\bootstrap\BootstrapAsset', // Esta línea
+];
+```
+
+Usar bootstrap a través de el gestor de recursos Yii te permite minimizar estos recursos y combinar con tus propios recursos cuando sea necesario..
+
+Widgets de Yii
+-----------
+
+Componentes más complejos de bootstrap components están envueltos dentro de widgets de Yii para permitir una sintaxis más robusta e integrar con las posibilidades y características del framework. Todos los widgets pertenecen al espacio de nombres `\yii\bootstrap` :
+
+- [[yii\bootstrap\ActiveForm|ActiveForm]]
+- [[yii\bootstrap\Alert|Alert]]
+- [[yii\bootstrap\Button|Button]]
+- [[yii\bootstrap\ButtonDropdown|ButtonDropdown]]
+- [[yii\bootstrap\ButtonGroup|ButtonGroup]]
+- [[yii\bootstrap\Carousel|Carousel]]
+- [[yii\bootstrap\Collapse|Collapse]]
+- [[yii\bootstrap\Dropdown|Dropdown]]
+- [[yii\bootstrap\Modal|Modal]]
+- [[yii\bootstrap\Nav|Nav]]
+- [[yii\bootstrap\NavBar|NavBar]]
+- [[yii\bootstrap\Progress|Progress]]
+- [[yii\bootstrap\Tabs|Tabs]]
+
+
+Usando los ficheros .less de Bootstrap directamente
+-------------------------------------------
+
+Si quieres incluir el [Css Bootstrap directamente en tus ficheros less](http://getbootstrap.com/getting-started/#customizing) puedes necesitar desactivar la carga los ficheros css originales de bootstrap.
+Esto lo puedes hacer poniendo la propiedad css de [[yii\bootstrap\BootstrapAsset|BootstrapAsset]] vacía.
+Para esto necesitas configurar el `assetManager` [componente de la aplicación](structure-application-components.md) como sigue:
+
+```php
+    'assetManager' => [
+        'bundles' => [
+            'yii\bootstrap\BootstrapAsset' => [
+                'css' => [],
+            ]
+        ]
+    ]
+```

docs/guide-es/widget-jui.md

+Widgets de Jquery UI
+====================
+
+> Nota: Esta sección está en desarrollo.
+
+Además de lo anterior, Yii incluye soporte para la librería jquery [jQuery UI](http://api.jqueryui.com/). jQuery UI es un probado conjunto de  interacciones con el interface de usuario, efectos, widgets, y temas sobre la librería JavaScript de jquery.
+
+widgets de Yii
+--------------
+
+Los componentes más complejos de jQuery UI están envueltos dentro de los widgets de Yii para permitir una sintaxis más robusta e integralas con las características del framework. Todos los widgets pertenecen al espacio de nombre  `\yii\jui` :
+
+- [[yii\jui\Accordion|Accordion]]
+- [[yii\jui\AutoComplete|AutoComplete]]
+- [[yii\jui\DatePicker|DatePicker]]
+- [[yii\jui\Dialog|Dialog]]
+- [[yii\jui\Draggable|Draggable]]
+- [[yii\jui\Droppable|Droppable]]
+- [[yii\jui\Menu|Menu]]
+- [[yii\jui\ProgressBar|ProgressBar]]
+- [[yii\jui\Resizable|Resizable]]
+- [[yii\jui\Selectable|Selectable]]
+- [[yii\jui\Slider|Slider]]
+- [[yii\jui\SliderInput|SliderInput]]
+- [[yii\jui\Sortable|Sortable]]
+- [[yii\jui\Spinner|Spinner]]
+- [[yii\jui\Tabs|Tabs]]
\ No newline at end of file