DOCUMENTATION[ES] New Files

- Zend_Controller-Request.xml
- Zend_Json-Basics.xml
- Zend_Json-Introduction.xml
- Zend_Json-Objects.xml
- Zend_Json-Server.xml
- Zend_Json-xml2json.xml
- Zend_Pdf-Create.xml
- Zend_Pdf-Introduction.xml
- Zend_Pdf-Pages.xml
- Zend_Pdf-Save.xml

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@16071 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/es/module_specs/Zend_Controller-Request.xml

@@ -14,161 +14,162 @@
 
         <itemizedlist>
             <listitem><para>
-                The module name is accessed by
-                <code>getModuleName()</code> and
+            	El nombre del módulo es accedido por 
+                <code>getModuleName()</code> y
                 <code>setModuleName()</code>.
             </para></listitem>
 
             <listitem><para>
-                The controller name is accessed by
-                <code>getControllerName()</code> and
+            	El nombre del controlador es accedido por 
+                <code>getControllerName()</code> y
                 <code>setControllerName()</code>.
             </para></listitem>
 
             <listitem><para>
-                The name of the action to call within that controller is
-                accessed by <code>getActionName()</code> and
+            	El nombre de la acción a llamar dentro el controlador es 
+            	accedido por <code>getActionName()</code> y
                 <code>setActionName()</code>.
             </para></listitem>
 
             <listitem><para>
-                Parameters to be accessible by the action are an associative array
-                of key/value pairs that are retrieved by <code>getParams()</code>
-                and set with <code>setParams()</code>, or individually by
-                <code>getParam()</code> and <code>setParam()</code>.
+            	Los parámetros al ser accesibles por la acción son una asociación de pares 
+            	de array llave/valor que son recuperdos por <code>getParams()</code>
+                y configurados con <code>setParams()</code>, o configurados individualmente por
+                <code>getParam()</code> y <code>setParam()</code>.
             </para></listitem>
         </itemizedlist>
 
         <para>
-            Based on the type of request, there may be more methods available.
-            The default request used, <classname>Zend_Controller_Request_Http</classname>,
-            for instance, has methods for retrieving the request URI, path
-            information, <code>$_GET</code> and <code>$_POST</code> parameters,
+        	Basado en el tipo de solicitud, puede haber más métodos disponibles.
+        	La solicitud por defecto usa, <classname>Zend_Controller_Request_Http</classname>,
+            para instanciar, tiene métodos para recuperar la solicitud URI, ruta de la 
+            información, parámetros <code>$_GET</code> y <code>$_POST</code>,
             etc.
         </para>
 
         <para>
-            The request object is passed to the front controller, or if none is
-            provided, it is instantiated at the beginning of the dispatch
-            process, before routing occurs. It is passed through to every object
-            in the dispatch chain.
+        	la solicitud objeto es pasada al controlador front, o si no es 
+        	previsto, es instanciado al principio del proceso despachador,
+        	antes de que ocurra unenrutamiento. Es pasado a través de todos los objetos
+            en la cadena del despachador.
         </para>
 
         <para>
-            Additionally, the request object is particularly useful in testing.
-            The developer may craft the request environment, including module,
-            controller, action, parameters, URI, etc, and pass the request
-            object to the front controller to test application flow. When paired
-            with the <link linkend="zend.controller.response">response
-                object</link>, elaborate and precise unit testing of MVC
-            applications becomes possible.
+        	Adicionalmente, la solicitud objeto es particularmente usado en pruebas.
+        	El desarrolador puede cambiar el entorno de la solicitud, incluyendo módulos,
+        	controladores, acciones, parámetros, URI, etc, y pasar la solicitud 
+        	objeto al controlador front para probar el flujo de la aplicación. Cuando se vincula 
+        	con el <link linkend="zend.controller.response">objeto 
+        		respuesta </link>,es posible elaborar y precisar una unidad de pruebas de aplicaciones
+        	MVC.
         </para>
     </sect2>
 
     <sect2 id="zend.controller.request.http">
-        <title>HTTP Requests</title>
+        <title>Solicitud HTTP</title>
 
         <sect3 id="zend.controller.request.http.dataacess">
-            <title>Accessing Request Data</title>
+            <title>Solicitud de acceso a datos</title>
 
             <para>
-                <classname>Zend_Controller_Request_Http</classname> encapsulates access to
-                relevant values such as the key name and value for the
-                controller and action router variables, and all additional
-                parameters parsed from the URI. It additionally allows access to
-                values contained in the superglobals as public members, and
-                manages the current Base URL and Request URI. Superglobal
-                values cannot be set on a request object, instead use the
-                setParam/getParam methods to set or retrieve user parameters.
+                <classname>Zend_Controller_Request_Http</classname> encapsula el acceso a 
+                relevantes valores tal como el nombre de la llave y el valor para el
+                controlador y variables de aación enrutamiento y todos los
+                parámetros adicionales analizados desde el URI. Adiccionalmente permite el acceso
+                a valores contenidos en las superglobales como miembros públicos y 
+                administra la actual base URL y la solicitud URI. los valores
+                Superglobales no pueden ser determinados en una solicitud objeto, en vez usar los
+                métodos setParam/getParam para determinar o recuperar los parámetros del usuario.
             </para>
 
             <note>
-                <title>Superglobal Data</title>
+                <title>Datos Superglobales</title>
                 <para>
-                    When accessing superglobal data through
-                    <classname>Zend_Controller_Request_Http</classname> as public member
-                    properties, it is necessary to keep in mind that the
-                    property name (superglobal array key) is matched to a
-                    superglobal in a specific order of precedence: 1. GET, 2.
+                	Cuando se accede a datos Superglobales a través 
+                    <classname>Zend_Controller_Request_Http</classname> como propiedades de miembros 
+                    públicos, es necesario mantener en mente que el nombre de la 
+                    propiedad (supergloabl array key) corresponda a una 
+                    supergloabl en un específico orden de precedencia:1. GET, 2.
                     POST, 3. COOKIE, 4. SERVER, 5. ENV.
                 </para>
             </note>
 
             <para>
-                Specific superglobals can be accessed using a public method as
-                an alternative. For example, the raw value of
-                <code>$_POST['user']</code> can be accessed by calling
-                <code>getPost('user')</code> on the request object. These
-                include <code>getQuery()</code> for retrieving
-                <code>$_GET</code> elements, and <code>getHeader()</code> for
-                retrieving request headers.
+            	Las supergloables específicas pueden ser accedidas usando un método público como
+            	una alternativa. Por ejemplo, el valor original de
+                <code>$_POST['user']</code> puede ser accedido llamando a 
+                <code>getPost('user')</code> en la solicitud objeto. Esto 
+                incluye <code>getQuery()</code> para recuperar elementos
+                <code>$_GET</code>, y <code>getHeader()</code> para
+                recuperar la solicitud de los encabezadores (headers).
             </para>
 
             <note>
-                <title>GET and POST Data</title>
+                <title>Datos GET y POST</title>
                 <para>
-                    Be cautious when accessing data from the request object as
-                    it is not filtered in any way. The router and dispatcher
-                    validate and filter data for use with their tasks, but leave
-                    the data untouched in the request object.
+                	Sea cauteloso cuando accede a los datos de la solicitud objeto como 
+                	no es filtrado en ninguna manera. El router y dispatcher 
+                	valida y filtra datos para usar con sus tareas, pero dejan
+                	los datos intactos en la solicitud objeto.
                 </para>
             </note>
 
             <note>
-                <title>Retrieving the Raw POST Data</title>
+                <title>Recuperando los datos POST sin procesar</title>
 
                 <para>
-                    As of 1.5.0, you can also retrieve the raw post data via the
-                    <code>getRawBody()</code> method. This method returns false
-                    if no data was submitted in that fashion, but the full body
-                    of the post otherwise.
+                	Como 1.5.0, se puede recuperar los datos sin procesar a través del
+                	método <code>getRawBody()</code>. Este método retorna falso
+                	si los datos han sido enviados de esa manera, pero si no retorna el cuerpo
+                	entero del post.
                 </para>
 
                 <para>
-                    This is primarily useful for accepting content when
-                    developing a RESTful MVC application.
+                	Esto es primordialmente útil para aceptar el contenido cuando
+                	se desarrolla una aplicación MVC simple.
                 </para>
             </note>
 
             <para>
-                You may also set user parameters in the request object using
-                <code>setParam()</code> and retrieve these later using
-                <code>getParam()</code>. The router makes use of this
-                functionality to set parameters matched in the request URI into
-                the request object.
+            	Usted puede determinar parámetros de usuario en la solicitud objeto usando
+            	<code>setParam()</code> y recuperar los mismos despues usando
+                <code>getParam()</code>. El router hace uso de esta 
+                funcionalidad para determinar parámetros correspondientes en la solicitud URI 
+                a la solicitud objeto.
             </para>
 
             <note>
-                <title>getParam() Retrieves More than User Parameters</title>
+                <title>getParam() Recupera mas que Parámetros de Usuario</title>
 
                 <para>
-                    In order to do some of its work, <code>getParam()</code> actually
-                    retrieves from several sources. In order of priority, these
-                    include: user parameters set via <code>setParam()</code>,
-                    <code>GET</code> parameters, and finally <code>POST</code>
-                    parameters. Be aware of this when pulling data via this
-                    method.
+                	En orden para hacer el mismo trabajo, <code>getParam()</code> recupera
+                	actualmente desde muchas fuentes. En orden de prioridad, estas 
+                	incluyen: parámetros de usuario determinados a través de <code>setParam()</code>,
+                    parámetros <code>GET</code>, y finalmente parámetros <code>POST</code>. 
+                    Ser conciente de esto cuando se sacan datos a través de este
+                    método.
                 </para>
 
                 <para>
-                    If you wish to pull only from parameters you set via
-                    <code>setParam()</code>, use the <code>getUserParam()</code>.
+                	Si se desea sacar solo desde parámetros se configura a través de
+                    <code>setParam()</code>, use <code>getUserParam()</code>.
                 </para>
 
                 <para>
-                    Additionally, as of 1.5.0, you can lock down which parameter
-                    sources will be searched. <code>setParamSources()</code>
-                    allows you to specify an empty array or an array with one or
-                    more of the values '_GET' or '_POST' indicating which
-                    parameter sources are allowed (by default, both are
-                    allowed); if you wish to restrict access to only '_GET'
-                    specify <code>setParamSources(array('_GET'))</code>.
+                	Además, a partir de 1.5.0, puede bloquear el parámetro que
+                    se buscará en las fuentes. <code>setParamSources()</code>
+                    le permite especificar un array vacío o un array con uno o
+                    más de los valores '_GET' o '_POST', indicando que
+                    fuente de parámetro se permite (por defecto, ambos son
+                    permitidos); si se desea restringir el acceso a solamente '_GET'
+                    especificar <code>setParamSources (array('_GET'))</code>.
                 </para>
             </note>
 
             <note>
                 <title>Apache Quirks</title>
                 <para>
+                	Si está usando Apache 404 handler para pasar 
                     If you are using Apache's 404 handler to pass incoming
                     requests to the front controller, or using a PT flag with
                     rewrite rules, <code>$_SERVER['REDIRECT_URL']</code>
@@ -403,20 +404,20 @@ abstract class Zend_Controller_Request_Abstract
 ]]></programlisting>
 
         <para>
-            The request object is a container for the request environment. The
-            controller chain really only needs to know how to set and retrieve the
-            controller, action, optional parameters, and dispatched status. By
-            default, the request will search its own parameters using the
-            controller or action keys in order to determine the controller and
-            action.
+        	La solicitud objeto es un contenedor para entorno de la solicitud. La
+			cadena del controlador sólo necesita saber cómo establecer y recuperar el
+			controlador, la acción, los parámetros opcionales, y el estado del despachador. Por
+			defecto, la solicitud buscará sus propios parámetros mediante el
+			controlador o las llaves de la acción con el fin de determinar el controlador y
+			la acción.
         </para>
 
         <para>
-            Extend this class, or one of its derivatives, when you need the
-            request class to interact with a specific environment in order to
-            retrieve data for use in the above tasks. Examples include <link
-                linkend="zend.controller.request.http">the HTTP
-                environment</link>, a CLI environment, or a PHP-GTK environment.
+     	 	Para ampliar esta clase, o uno de sus derivados, cuando se necesita la
+			clase solicitud que interactue con un entorno específico con el fin de
+			recuperar los datos para su uso en las tareas antes descritas. Los ejemplos incluyen <link
+				linkend = "zend.controller.request.http"> el entorno HTTP
+				</link>, un entorno CLI, o un entorno de PHP-GTK.
         </para>
     </sect2>
 </sect1>

documentation/manual/es/module_specs/Zend_Json-Basics.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.json.basics">
+    <title>Uso Básico</title>
+    <para>
+        El uso de <classname>Zend_Json</classname> consiste en utilizar los dos 
+        métodos públicos estáticos disponibles: 
+        <classname>Zend_Json::encode()</classname> y
+        <classname>Zend_Json::decode()</classname>.
+    </para>
+    <programlisting role="php"><![CDATA[
+// Recuperar un valor:
+$phpNative = Zend_Json::decode($encodedValue);
+
+// Codificarlo para regresarlo al cliente:
+$json = Zend_Json::encode($phpNative);
+]]></programlisting>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Json-Introduction.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.json.introduction">
+    <title>Introducción</title>
+    <para>
+        <classname>Zend_Json</classname> ofrece métodos convenientes para la 
+        serialización desde PHP nativo a JSON y la decodificación JSON a PHP 
+        nativo. Para más información sobre JSON, <ulink url="http://www.json.org/">
+        visite el sitio del proyecto JSON</ulink>.
+    </para>
+    <para>
+        JSON, JavaScript Object Notation, puede ser utilizado para intercambio 
+        de datos entre JavaScript y otros lenguajes. 
+        Dado que JSON puede ser evaluado directamente por JavaScript, es más 
+        eficiente y ligero que el formato XML para intercambiar datos con 
+        clientes JavaScript.
+    </para>
+
+    <para>
+        Adicionalmente, <classname>Zend_Json</classname> provee una forma útil 
+        para convertir cualquier string arbitrario con formato XML en un string 
+        con formato JSON. Este rasgo integral permite a desarrolladores PHP 
+        transformar los datos codificados de la empresa en formato XML a 
+        formato JSON antes de enviarlos a las aplicaciones del cliente Ajax 
+        basadas en navegadores web. Provee una manera fácil de hacer 
+        conversiones dinámicas de datos del código en el servidor evitando así 
+        el innecesario parsing de XML de las aplicaciones en el navegador.  
+        Ofrece una agradable función útil que facilita las técnicas de 
+        procesamiento de datos para aplicaciones específicas.
+    </para>
+
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Json-Objects.xml

@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.json.advanced">
+    <title>Uso Avanzado de Zend_Json</title>
+
+    <sect2 id="zend.json.advanced.objects1">
+        <title>Objetos JSON</title>
+        <para>
+            Cuando se codifican objetos PHP como JSON, todas las propiedades 
+            públicas de ese objeto serán codificadas en un objeto JSON.
+        </para>
+        <para>
+            JSON no permite referencias a objetos, de manera que debe tenerse 
+            cuidado de no codificar objetos con referencias recursivas. 
+            Si tiene problemas con la recursión, 
+            <classname>Zend_Json::encode()</classname> y 
+            <classname>Zend_Json_Encoder::encode()</classname> permiten un 
+            segundo parámetro opcional para comprobar si hay recursión; si un 
+            objeto es serializado dos veces, se emitirá una excepción.
+        </para>
+        <para>
+            La decodificación de objetos JSON plantea una dificultad adicional, 
+            sin embargo, ya que los objetos Javascript se corresponden más 
+            estrechamente a un array asociativo de PHP. 
+            Algunos sugieren que debe pasarse un identificador de clase, y una  
+            instancia del objeto de esa clase debe crearse y alimentarla con datos 
+            de pares clave/valor del objeto JSON; otros consideran que esto podría 
+            plantear un considerable riesgo de seguridad.
+        </para>
+        <para>
+            Por defecto, <classname>Zend_Json</classname> decodificará objetos 
+            JSON como arrays asociativos. Sin embargo, si desea retornar un 
+            objeto, puede especificar esto:
+        </para>
+        <programlisting role="php"><![CDATA[
+// Decodifica objetos JSON como objetos PHP
+$phpNative = Zend_Json::decode($encodedValue, Zend_Json::TYPE_OBJECT);
+]]></programlisting>
+        <para>
+            Por lo tanto, cualquiera de los objetos decodificados son devueltos 
+            como objetos <code>StdClass</code> con propiedades correspondientea 
+            a pares clave/valor en la notación JSON.
+        </para>
+        <para>
+            La recomendación de Zend Framework es que el desarrollador debe 
+            decidir cómo decodificar objetos JSON. Si debe crearse un objeto de 
+            un determinado tipo, puede ser creado en el código del desarrollador 
+            y alimentado con datos de los valores decodificados utilizando 
+            <classname>Zend_Json</classname>.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.json.advanced.objects2">
+        <title>Codificando Objetos PHP</title>
+
+        <para>
+            Si se codifican objetos PHP por defecto, el mecanismo de codificación 
+            sólo tiene acceso a las propiedades públicas de estos objetos. 
+            Cuando se implementa un método <code>toJson()</code> en un objeto a 
+            codificar, <classname>Zend_Json</classname> llama a este método y 
+            espera que el objeto devuelva una representación JSON de su estado  
+            interno.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.json.advanced.internal">
+        <title>Codificador/Decodificador Interno</title>
+
+        <para>
+            Zend_Json tiene dos modos diferentes dependiendo de si ext/json está 
+            habilitada o no en su instalación PHP. Si ext/json está instalado 
+            por defecto, las funciones <code>json_encode()</code> y 
+            <code>json_decode()</code> se utilizan para la codificación y 
+            decodificación JSON. Si ext/json no está instalado, una implementación 
+            de Zend Framework en código PHP es utilizada para la 
+            codificación/decodificación. Esto es considerablemente más lento que 
+            usando la extensión de php, pero se comporta exactamente igual.
+        </para>
+
+        <para>
+            También algunas veces puede querer utilizar el codificador/decodificador 
+            interno incluso si tiene ext/json instalado. Puede hacer esto 
+            llamando a:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+Zend_Json::$useBuiltinEncoderDecoder = true:
+]]></programlisting>
+    </sect2>
+
+    <sect2 id="zend.json.advanced.expr">
+        <title>Expresiones JSON</title>
+
+        <para>
+            Javascript hace uso intenso de las funciones anónimas de llamadas 
+            de retorno, que pueden guardarse en variables del objeto JSON. 
+            Aunque solo funcionan si no regresaron dentro comillas dobles, que 
+            es lo que hace naturalmente <classname>Zend_Json</classname>. 
+            Con la Expression de apoyo para Zend_Json este apoyo puede codificar  
+            objetos JSON con callbacks validos de javascript. 
+            Esto funciona tanto con <code>json_encode()</code> como con el 
+            codificador interno.
+        </para>
+
+        <para>
+            Un callback javascript se representa usando el objero 
+            <classname>Zend_Json_Expr</classname>. Este implementa el patrón del 
+            objeto valor y es inmutable. Se puede establecer la expresión de  
+            javascript como el primer argumento del constructor. 
+            Por defecto <classname>Zend_Json::encode</classname> no codifica 
+            callbacks javascript, usted tiene que pasar la opción 
+            <code>'enableJsonExprFinder' = true</code> dentro de la función 
+            <code>encode</code>. Si se habilita, la expresión de apoyo trabaja 
+            para todas las expresiones anidadas en grandes estructuras de objetos. 
+            Un ejemplo de uso se vería así:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$data = array(
+    'onClick' => new Zend_Json_Expr('function() {'
+              . 'alert("Yo soy un callback válido de javascript '
+              . 'creado por Zend_Json"); }'),
+    'other' => 'sin expresión',
+);
+$jsonObjectWithExpression = Zend_Json::encode(
+    $data,
+    false,
+    array('enableJsonExprFinder' => true)
+);
+]]></programlisting>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Json-Server.xml

@@ -0,0 +1,641 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.json.server">
+    <title>Zend_Json_Server - servidor JSON-RPC</title>
+
+    <para>
+        <classname>Zend_Json_Server</classname> es una implementación del 
+            servidor <ulink
+            url="http://groups.google.com/group/json-rpc/">JSON-RPC</ulink>
+        Soporta tanto la versión 1 de la especificación  
+        <ulink url="http://json-rpc.org/wiki/specification">JSON-RPC</ulink> 
+        así como la especificación de la 
+        <ulink url="http://groups.google.com/group/json-rpc/web/json-rpc-1-2-proposal">versión 2</ulink>;
+        además, provee una implementación de PHP de la especificación del
+        <ulink url="http://groups.google.com/group/json-schema/web/service-mapping-description-proposal">Service
+            Mapping Description (SMD)</ulink>
+        para prestar un servicio de metadatos a consumidores del servicio.
+    </para>
+
+    <para>
+        JSON-RPC es un protocolo liviano de Remote Procedure Call que utiliza JSON 
+        para envolver sus mensajes. Esta implementación JSON-RPC sigue la API 
+        PHP de <ulink
+            url="http://us.php.net/manual/en/function.soap-soapserver-construct.php">SoapServer</ulink>.
+        Esto significa que, en una situación típica, simplemente:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>Instancia el objeto servidor</para></listitem>
+        <listitem><para>Agrega una o más funciones y/o clases/objetos al objeto 
+                servidor para</para></listitem>
+        <listitem><para>handle() -- maneja -- el requerimiento</para></listitem>
+    </itemizedlist>
+
+    <para>
+        <classname>Zend_Json_Server</classname> utiliza <xref linkend="zend.server.reflection" /> 
+        para realizar reflexión sobre cualquiera de las clases o funciones 
+        agregadas, y utiliza esa información para construir tanto la SMD y 
+        hacer cumplir el método de llamado de firmas. 
+        Como tal, es imperativo que cualquier de las funciones agregadas y/o 
+        los métodos de clase tengan mínimamente una plena documentación de 
+        PHP docblocks: 
+    </para>
+
+    <itemizedlist>
+        <listitem><para>Todos los parámetros y sus tipos de variables esperados</para></listitem>
+        <listitem><para>El tipo de variable del valor de retorno</para></listitem>
+    </itemizedlist>
+
+    <para>
+        <classname>Zend_Json_Server</classname> escucha por solicitudes POST 
+        únicamente en este momento; afortunadamente, la mayoría de las 
+        implementaciones del cliente JSON-RPC en los medios en el momento de 
+        escribir esto, sólo requieren a POST como es. 
+        Esto hace que sea fácil de utilizar el mismo punto final del servidor  
+        para manejar a ambas peticiones así como para entregar el servicio SMD, 
+        como se muestra en el siguiente ejemplo.
+    </para>
+
+    <example id="zend.json.server.usage">
+        <title>Uso de Zend_Json_Server</title>
+
+        <para>
+            Primero, definir una clase que queramos exponer vía servidor JSON-RPC. 
+            Vamos a la clase 'Calculator', y definir los métodos para
+            'add', 'subtract', 'multiply', y 'divide':
+        </para>
+
+        <programlisting role="php"><![CDATA[
+/**
+ * Calculator - clase de ejemplo para exponer via JSON-RPC
+ */
+class Calculator
+{
+    /**
+     * Devuelve la suma de dos variables
+     *
+     * @param  int $x
+     * @param  int $y
+     * @return int
+     */
+    public function add($x, $y)
+    {
+        return $x + $y;
+    }
+
+    /**
+     * Devuelve la diferencia de dos variables
+     *
+     * @param  int $x
+     * @param  int $y
+     * @return int
+     */
+    public function subtract($x, $y)
+    {
+        return $x - $y;
+    }
+
+    /**
+     * Devuelve el producto de dos variables
+     *
+     * @param  int $x
+     * @param  int $y
+     * @return int
+     */
+    public function multiply($x, $y)
+    {
+        return $x * $y;
+    }
+
+    /**
+     * Devuelve la división de dos variables
+     *
+     * @param  int $x
+     * @param  int $y
+     * @return float
+     */
+    public function divide($x, $y)
+    {
+        return $x / $y;
+    }
+}
+]]></programlisting>
+
+        <para>
+            Nótese que cada método tiene un docblock con entradas indicando cada 
+            parámetro y su tipo, así como una entrada para el valor de retorno.
+            Esto es <emphasis>absolutamente crítico</emphasis> cuando se usa 
+            <classname>Zend_Json_Server</classname> -- o cualquier otro 
+            componente del servidor en Zend Framework, por esa cuestión.
+        </para>
+
+        <para>
+            Ahora, crearemos un script para manejar las peticiones:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$server = new Zend_Json_Server();
+
+// Indicar que funcionalidad está disponible:
+$server->setClass('Calculator');
+
+// Manejar el requerimiento:
+$server->handle();
+]]></programlisting>
+
+        <para>
+            Sin embargo, esto no soluciona el problema de devolución de un SMD 
+            para que el cliente JSON-RPC pueda autodescubrir los métodos. 
+            Esto puede lograrse determinando el método del requerimiento HTTP, 
+            y luego especificando algún servidor de metadatos:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$server = new Zend_Json_Server();
+$server->setClass('Calculator');
+
+if ('GET' == $_SERVER['REQUEST_METHOD']) {
+    // Indica el punto final de la URL, y la versión en uso de JSON-RPC:
+    $server->setTarget('/json-rpc.php')
+           ->setEnvelope(Zend_Json_Server_Smd::ENV_JSONRPC_2);
+
+    // Capturar el SMD
+    $smd = $server->getServiceMap();
+
+    // Devolver el SMD al cliente
+    header('Content-Type: application/json');
+    echo $smd;
+    return;
+}
+
+$server->handle();
+]]></programlisting>
+
+        <para>
+            Si utiliza el servidor JSON-RPC con Dojo toolkit, también necesitará 
+            establecer un flag de compatibilidad especial para garantizar 
+            que los dos interoperen correctamente:
+        </para>
+
+
+        <programlisting role="php"><![CDATA[
+$server = new Zend_Json_Server();
+$server->setClass('Calculator');
+
+if ('GET' == $_SERVER['REQUEST_METHOD']) {
+    $server->setTarget('/json-rpc.php')
+           ->setEnvelope(Zend_Json_Server_Smd::ENV_JSONRPC_2);
+    $smd = $server->getServiceMap();
+
+    // Establecer la compatibilidad con Dojo:
+    $smd->setDojoCompatible(true);
+
+    header('Content-Type: application/json');
+    echo $smd;
+    return;
+}
+
+$server->handle();
+]]></programlisting>
+    </example>
+
+    <sect2 id="zend.json.server.details">
+        <title>Detalles Avanzados</title>
+
+        <para>
+            Aunque la mayor funcionalidad de <classname>Zend_Json_Server</classname> se
+            puntualiza en <xref linkend="zend.json.server.usage" />, hay
+            más funcionalidad avanzada disponible.
+        </para>
+
+        <sect3 id="zend.json.server.details.zendjsonserver">
+            <title>Zend_Json_Server</title>
+
+            <para>
+                <classname>Zend_Json_Server</classname> es la clase núcleo en la 
+                propuesta JSON-RPC; que maneja todas las peticiones y como 
+                respuesta devuelve un conjunto de datos. 
+                Tiene los siguientes métodos:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>addFunction($function)</code>: Especifica 
+                        la función de espacio del usuario para agregar al servidor.</para></listitem>
+                <listitem><para><code>setClass($class)</code>: Especifica una 
+                        clase u objeto para agregar al servidor; todos los métodos 
+                        públicos de ese item serán expuestos como métodos JSON-RPC.</para></listitem>
+                <listitem><para><code>fault($fault = null, $code = 404, $data =
+                        null)</code>: Crea y devuelve un objeto 
+                        <classname>Zend_Json_Server_Error</classname>.</para></listitem>
+                <listitem><para><code>handle($request = false)</code>: Maneja 
+                        una solicitud JSON-RPC; opcionalmente, pasa un objeto 
+                        <classname>Zend_Json_Server_Request</classname> a utlizar  
+                        (crea uno por defecto).</para></listitem>
+                <listitem><para><code>getFunctions()</code>: Devuelve una lista 
+                        de todos los métodos agregados.</para></listitem>
+                <listitem><para><code>setRequest(Zend_Json_Server_Request
+                        $request)</code>: Especifica un objeto solicitud para el 
+                        servidor a utilizar.</para></listitem>
+                <listitem><para><code>getRequest()</code>: Recupera el objeto 
+                        solicitud usado por el servidor.</para></listitem>
+                <listitem><para><code>setResponse(Zend_Json_Server_Response
+                        $response)</code>: Establece el objeto respuesta para el 
+                        servidor a utilizar.</para></listitem>
+                <listitem><para><code>getResponse()</code>: Recupera el objeto 
+                        respuesta usado por el servidor.</para></listitem>
+                <listitem><para><code>setAutoEmitResponse($flag)</code>:
+                        Indica si el servidor debería emitir automáticamente la 
+                        respuesta y todas las cabeceras; por defecto, esto es 
+                        verdadero.</para></listitem>
+                <listitem><para><code>autoEmitResponse()</code>: Determina si la 
+                        auto-emisión de la respuesta está habilitada.</para></listitem>
+                <listitem><para><code>getServiceMap()</code>: Recupera la 
+                        descripción del mapa de servicio en el form de un 
+                        objeto  
+                        <classname>Zend_Json_Server_Smd</classname>.</para></listitem>
+            </itemizedlist>
+        </sect3>
+
+        <sect3 id="zend.json.server.details.zendjsonserverrequest">
+            <title>Zend_Json_Server_Request</title>
+
+            <para>
+                El medio ambiente de una solicitud JSON-RPC está encapsulado en 
+                el objeto <classname>Zend_Json_Server_Request</classname>. 
+                Este objeto le permite establecer porciones necesarias de la 
+                solicitud JSON-RPC, incluida el ID de la solicitud, parámetros y 
+                especificaciones de la versión JSON-RPC. Tiene la capacidad de 
+                cargarse a sí mismo via JSON o un conjunto de opciones, y puede 
+                mostrase a si mismo como JSON vía el método <code>toJson()</code>.
+            </para>
+
+            <para>
+                El objeto solicitud tiene los siguientes métodos disponibles:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>setOptions(array $options)</code>: Especifica 
+                        la configuración del objeto. <code>$options</code> puede 
+                        contener claves que concuerden con cualuier método 'set':
+                        <code>setParams()</code>, <code>setMethod()</code>,
+                        <code>setId()</code>, y
+                        <code>setVersion()</code>.</para></listitem>
+                <listitem><para><code>addParam($value, $key = null)</code>: 
+                        Agrega un parámetro para usar con el método de llamada. 
+                        Los parámetros pueden ser sólo los valores, o pueden 
+                        incluir opcionalmente el nombre del parámetro.
+                        </para></listitem>
+                <listitem><para><code>addParams(array $params)</code>: Agrega 
+                        múltiples parámetros a la vez; proxies a
+                        <code>addParam()</code></para></listitem>
+                <listitem><para><code>setParams(array $params)</code>: 
+                        Establece todos los parámetros a la vez; sobrescribe 
+                        cualquiera de los parámetros existentes.</para></listitem>
+                <listitem><para><code>getParam($index)</code>: Recupera un 
+                        parámetro por posición o por el nombre.</para></listitem>
+                <listitem><para><code>getParams()</code>: Recupera todos los 
+                        parámetros a la vez.</para></listitem>
+                <listitem><para><code>setMethod($name)</code>: Establece el 
+                        método para llamar.</para></listitem>
+                <listitem><para><code>getMethod()</code>: Recupera el método que 
+                        será llamado.</para></listitem>
+                <listitem><para><code>isMethodError()</code>: Determinar si la 
+                        solicitud está malformada o no y si daría como resultado 
+                        un error.</para></listitem>
+                <listitem><para><code>setId($name)</code>: Establecer el 
+                        identificador de solicitud(utilizado por el cliente 
+                        para igualar las solicitudes de respuestas).</para></listitem>
+                <listitem><para><code>getId()</code>: Recuperar el identificador 
+                        de solicitudes.</para></listitem>
+                <listitem><para><code>setVersion($version)</code>: Establecer la 
+                        versión de la especificación JSON-RPC que conforma la 
+                        solicitud. Puede ser '1.0' o '2.0'.</para></listitem>
+                <listitem><para><code>getVersion()</code>: Recuperar la versión 
+                        de la especificación JSON-RPC utilizados por la solicitud.
+                        </para></listitem>
+                <listitem><para><code>loadJson($json)</code>: Cargar el objeto 
+                        solicitud de una cadena JSON.</para></listitem>
+                <listitem><para><code>toJson()</code>: Mostrar la solicitud como 
+                        un string JSON.</para></listitem>
+            </itemizedlist>
+
+            <para>
+                Una versión específica de HTTP está disponible a través de
+                <classname>Zend_Json_Server_Request_Http</classname>. Esta clase 
+                podrá recuperar la solicitud via <code>php://input</code>, y 
+                permite el acceso JSON sin procesar vía el método 
+                <code>getRawJson()</code>. 
+            </para>
+        </sect3>
+
+        <sect3 id="zend.json.server.details.zendjsonserverresponse">
+            <title>Zend_Json_Server_Response</title>
+
+            <para>
+                La respuesta del conjunto de datos JSON-RPC es encapsulada en el 
+                objeto <classname>Zend_Json_Server_Response</classname>. 
+                Este objeto le permite ajustar el valor de retorno de la 
+                solicitud, siendo la respuesta un error o no, el identificador 
+                de solicitud, con que versión de especificación esta conformada 
+                la respuesta de JSON-RPC, y, opcionalmente el mapa de servicio.
+            </para>
+
+            <para>
+                El objeto respuesta tiene los siguientes métodos disponibles:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>setResult($value)</code>: Establecer el 
+                        resultado de la respuesta.</para></listitem>
+                <listitem><para><code>getResult()</code>: Recuperar el resultado 
+                        de la respuesta.</para></listitem>
+                <listitem><para><code>setError(Zend_Json_Server_Error
+                    $error)</code>: Establecer un objeto error. Si ya está, este 
+                    será utilizado como la respuesta cuando se serialize a JSON.
+                    </para></listitem>
+                <listitem><para><code>getError()</code>: Recuperar el objeto 
+                    error, si lo hubiera.</para></listitem>
+                <listitem><para><code>isError()</code>: Si la respuesta es una 
+                        respuesta de error o no.</para></listitem>
+                <listitem><para><code>setId($name)</code>: Establecer el 
+                        identificador de solicitud (de manera que la respuesta 
+                        del cliente pueda coincidir con la solicitud original).
+                        </para></listitem>
+                <listitem><para><code>getId()</code>: Recuperar el identificador 
+                        de solicitud.</para></listitem>
+                <listitem><para><code>setVersion($version)</code>: Establecer la 
+                        versión JSON-RPC con la que deba estar conformada la 
+                        respuesta.</para></listitem>
+                <listitem><para><code>getVersion()</code>: Recuperar la versión 
+                        JSON-RPC con la cumple la respuesta.</para></listitem>
+                <listitem><para><code>toJson()</code>: Serializar la respuesta a 
+                        JSON. Si la respuesta es una respuesta de error, 
+                        serializar el objeto error.</para></listitem>
+                <listitem><para><code>setServiceMap($serviceMap)</code>: 
+                        Establecer el objeto mapa de servicio para la respuesta.
+                        </para></listitem>
+                <listitem><para><code>getServiceMap()</code>: Recuperar el objeto 
+                        mapa de servicio, si hubiera alguno.</para></listitem>
+            </itemizedlist>
+
+            <para>
+                Una versión específica de HTTP está disponible a través de 
+                <classname>Zend_Json_Server_Response_Http</classname>. Esta clase 
+                enviará las cabeceras HTTP apropiadas así como serializará la 
+                respuesta como JSON.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.json.server.details.zendjsonservererror">
+            <title>Zend_Json_Server_Error</title>
+
+            <para>
+                JSON-RPC tiene un formato especial para informar condiciones de 
+                error. Todos los errores necesitan proporcionar, mínimamente, 
+                un mensaje de error y un código de error; opcionalmente, pueden 
+                proporcionar datos adicionales, tales como un backtrace.
+            </para>
+
+            <para>
+                Los códigos de error derivan de los recomendados por <ulink
+                    url="http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php">el 
+                    proyecto XML-RPC EPI</ulink>. <classname>Zend_Json_Server</classname>
+                apropiadamente asigna el código sobre la base de la condición de 
+                error. Para las excepciones de la aplicación, se utiliza el 
+                código '-32000'.
+            </para>
+
+            <para>
+                <classname>Zend_Json_Server_Error</classname> expone los 
+                siguientes métodos:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>setCode($code)</code>: Establece el código 
+                    de error; si el código de error no está en el rango de 
+                    aceptación de XML-RPC, -32000 será asignado.</para></listitem>
+                <listitem><para><code>getCode()</code>: Recuperar el actual 
+                    código de error.</para></listitem>
+                <listitem><para><code>setMessage($message)</code>: Establecer el 
+                    mensaje de error.</para></listitem>
+                <listitem><para><code>getMessage()</code>: Recuperar el mensaje 
+                    de error actual.</para></listitem>
+                <listitem><para><code>setData($data)</code>: Establecer el conjunto 
+                    de datos auxiliares para calificar más adelante el error, 
+                    tal como un backtrace.</para></listitem>
+                <listitem><para><code>getData()</code>: Recuperar cualquier 
+                    auxiliar actual de errores de datos.</para></listitem>
+                <listitem><para><code>toArray()</code>: Mandar el error a un 
+                    array. El array contendrá las claves 'code', 'message', 
+                    y 'data'.</para></listitem>
+                <listitem><para><code>toJson()</code>: Mandar el error a una 
+                    representación de error JSON-RPC.</para></listitem>
+            </itemizedlist>
+        </sect3>
+
+        <sect3 id="zend.json.server.details.zendjsonserversmd">
+            <title>Zend_Json_Server_Smd</title>
+
+            <para>
+                SMD quiere decir Service Mapping Description, un esquema JSON que 
+                define cómo un cliente puede interactuar con un servicio web en 
+                particular. En el momento de escribir esto, la <ulink
+                    url="http://groups.google.com/group/json-schema/web/service-mapping-description-proposal">especificación</ulink>
+                todavía no ha sido ratificada oficialmente, pero ya está en uso  
+                en Dojo toolkit así como en otros clientes consumidores de 
+                JSON-RPC.
+            </para>
+
+            <para>
+                En su aspecto más básico, un SMD indica el método de transporte 
+                (POST, GET, TCP/IP, etc), el tipo de envoltura de la solicitud  
+                (generalmente se basa en el protocolo del servidor), 
+                el objetivo URL del proveedor del servicio, y un mapa de los 
+                servicios disponibles. En el caso de JSON-RPC, el servicio de mapa 
+                es una lista de los métodos disponibles, en el que cada método 
+                documenta los parámetros disponibles y sus tipos, así como los 
+                tipos de valores esperados a devolver.
+            </para>
+
+            <para>
+                <classname>Zend_Json_Server_Smd</classname> Proporciona un objeto 
+                orientado para construir servicios de mapas. 
+                Básicamente, pasa los metadatos describiendo el servicio usando 
+                mutators, y especifica los servicios (métodos y funciones).
+            </para>
+
+            <para>
+                Las descripciones de los servicios son típicamente instancias de 
+                <classname>Zend_Json_Server_Smd_Service</classname>; también 
+                puede pasar toda la información como un array a los diversos 
+                mutators de servicios en <classname>Zend_Json_Server_Smd</classname>, 
+                y que instanciará on objeto de servicio por usted. 
+                Los objetos de servicio contienen información como el nombre del 
+                servicio (típicamente, la función o el nombre del método), los 
+                parámetros (nombres, tipos y posición), y el tipo del valor de 
+                retorno. Opcionalmente, cada servicio puede tener su propio 
+                objetivo y envoltura, aunque esta funcionalidad rara vez es utilizada.
+            </para>
+
+            <para>
+                <classname>Zend_Json_Server</classname> Realmente todo esto 
+                sucede entre bambalinas para usted, utilizando reflexión sobre 
+                las clases y funciones agregadas; debe crear su propio servicio 
+                de mapas sólo si necesita brindar funcionalidad personalizada que 
+                la introspección de clase y función no puede ofrecer.
+            </para>
+
+            <para>
+                Los métodos disponibles en <classname>Zend_Json_Server_Smd</classname> incluyen:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>setOptions(array $options)</code>: Establecer 
+                        un objeto SMD desde un array de opciones. Todos los 
+                        mutators (métodos comenzando con 'set') se pueden usar 
+                        como claves.</para></listitem>
+                <listitem><para><code>setTransport($transport)</code>: Establecer 
+                        el transporte usado para acceder al servicio; únicamente 
+                        POST es actualmente soportado.</para></listitem>
+                <listitem><para><code>getTransport()</code>: Obtener el servicio 
+                        de transporte actual.</para></listitem>
+                <listitem><para><code>setEnvelope($envelopeType)</code>: 
+                        Establecer la envoltura de la solicitud que debería ser 
+                        utilizada para acceder al servicio. Actualmente las  
+                        constantes soportadas son 
+                        <classname>Zend_Json_Server_Smd::ENV_JSONRPC_1</classname> y
+                        <classname>Zend_Json_Server_Smd::ENV_JSONRPC_1</classname>.</para></listitem>
+                <listitem><para><code>getEnvelope()</code>: Obtener la envoltura 
+                        de la petición actual.</para></listitem>
+                <listitem><para><code>setContentType($type)</code>: Establecer 
+                        el tipo de contenido que deben utilizar las solicitudes 
+                        (por defecto, es 'application/json»).</para></listitem>
+                <listitem><para><code>getContentType()</code>: Conseguir el 
+                        tipo del contenido actual para las solicitudes al 
+                        servicio.</para></listitem>
+                <listitem><para><code>setTarget($target)</code>: Establecer el 
+                        punto final de la URL para el servicio.</para></listitem>
+                <listitem><para><code>getTarget()</code>: Obtener el punto final 
+                        de la URL para el servicio.</para></listitem>
+                <listitem><para><code>setId($id)</code>: Normalmente, este es el 
+                        punto final de la URL del servicio (igual que el 
+                        objetivo).</para></listitem>
+                <listitem><para><code>getId()</code>: Recuperar el ID del servicio 
+                        (normalmente el punto final de la URL del servicio).
+                        </para></listitem>
+                <listitem><para><code>setDescription($description)</code>: 
+                        Establecer una descripción del servicio (típicamente 
+                        información narrativa que describe el propósito del 
+                        servicio).</para></listitem>
+                <listitem><para><code>getDescription()</code>: Obtener la 
+                        descripción del servicio.</para></listitem>
+                <listitem><para><code>setDojoCompatible($flag)</code>: 
+                        Establecer un flag que indique si el SMD es compatible 
+                        o no con el toolkit de Dojo. Cuando sea verdadero, el 
+                        JSON SMD será formateado para cumplir con el formato que 
+                        espera el cliente de Dojo JSON-RPC.</para></listitem>
+                <listitem><para><code>isDojoCompatible()</code>: Devuelve el valor 
+                        del flag de compatibilidad de Dojo (falso, por defecto).
+                        </para></listitem>
+                <listitem><para><code>addService($service)</code>: Añade un 
+                        servicio al mapa. Puede ser un array de información a 
+                        pasar al constructor de
+                        <classname>Zend_Json_Server_Smd_Service</classname>, o 
+                        una instancia de esa clase.</para></listitem>
+                <listitem><para><code>addServices(array $services)</code>: 
+                        Agrega múltiples servicios a la vez.</para></listitem>
+                <listitem><para><code>setServices(array $services)</code>: 
+                        Agrega múltiples servicios a la vez, sobreescribiendo 
+                        cualquiera de los servicios previamente establecidos.
+                        </para></listitem>
+                <listitem><para><code>getService($name)</code>: Ontiene el servicio 
+                        por su nombre.</para></listitem>
+                <listitem><para><code>getServices()</code>: Obtener todos los 
+                        servicios agregados.</para></listitem>
+                <listitem><para><code>removeService($name)</code>: Elimina un 
+                        servicio del mapa.</para></listitem>
+                <listitem><para><code>toArray()</code>: Mandar el mapa de servicio 
+                        a un array.</para></listitem>
+                <listitem><para><code>toDojoArray()</code>: Mandar el mapa de servicio 
+                        a un array compatible con Dojo Toolkit.</para></listitem>
+                <listitem><para><code>toJson()</code>: Mandar el mapa de servicio 
+                        a una representación JSON.</para></listitem> 
+            </itemizedlist>
+
+            <para>
+                <classname>Zend_Json_Server_Smd_Service</classname> tiene los 
+                        siguientes métodos:
+            </para>
+
+            <itemizedlist>
+                <listitem><para><code>setOptions(array $options)</code>: 
+                        Establecer el estado del objeto dede un array. Cualquier 
+                        mutator (métodos comenzando con 'set') puede ser utilizado 
+                        como una clave y establecerlo mediante este método.
+                        </para></listitem>
+                <listitem><para><code>setName($name)</code>: Establecer el nombre 
+                        del servicio (típicamente, la función o el nombre del 
+                        método).</para></listitem>
+                <listitem><para><code>getName()</code>: Recuperar el nombre del 
+                        servicio.</para></listitem>
+                <listitem><para><code>setTransport($transport)</code>: Establecer 
+                        el servicio de transporte (actualmente, sólo transportes 
+                        apoyados por <classname>Zend_Json_Server_Smd</classname> 
+                        son permitidos).</para></listitem>
+                <listitem><para><code>getTransport()</code>: Recuperar el transporte 
+                        actual.</para></listitem>
+                <listitem><para><code>setTarget($target)</code>: Establecer el 
+                        punto final de la URL del servicio (típicamente, este 
+                        será el mismo que el SMD en general, al cual el servicio 
+                        está agregado).</para></listitem>
+                <listitem><para><code>getTarget()</code>: Obtener el punto final 
+                        de la URL del servicio.</para></listitem>
+                <listitem><para><code>setEnvelope($envelopeType)</code>: 
+                        Establecer la envoltura del servicio (actualmente, sólo 
+                        se permiten las envolturas soportadas por 
+                        <classname>Zend_Json_Server_Smd</classname>.</para></listitem>
+                <listitem><para><code>getEnvelope()</code>: Recuperar el tipo de 
+                        envoltura del servicio.</para></listitem>
+                <listitem><para><code>addParam($type, array $options = array(),
+                            $order = null)</code>: Añadir un parámetro para el 
+                        servicio. Por defecto, sólo el tipo de parámetro es necesario. 
+                        Sin embargo, también puede especificar el orden, así como 
+                        opciones tales como:</para>
+                    <itemizedlist>
+                        <listitem><para><emphasis>name</emphasis>: el nombre del 
+                            parámetro</para></listitem>
+                        <listitem><para><emphasis>optional</emphasis>: cuándo 
+                            el parámetro es opcional o no</para></listitem>
+                        <listitem><para><emphasis>default</emphasis>: un valor 
+                            por defecto para el parámetro</para></listitem>
+                        <listitem><para><emphasis>description</emphasis>: texto 
+                            describiendo el parámetro</para></listitem>
+                    </itemizedlist>
+                </listitem>
+                <listitem><para><code>addParams(array $params)</code>: Agregar 
+                    varios parámetros a la vez; cada param debería ser un array 
+                    asociativo conteniendo mínimamente la clave 'type' describiendo 
+                    el tipo de parámetro y, opcionalmente la clave 'order'; 
+                    cualquiera de las otras claves serán pasados como 
+                    <code>$options</code> a <code>addOption()</code>.</para></listitem>
+                <listitem><para><code>setParams(array $params)</code>: 
+                    Establecer muchos parámetros a la vez, sobrescribiendo 
+                    cualquiera de los parámetros existentes.</para></listitem>
+                <listitem><para><code>getParams()</code>: Recuperar todos los 
+                    parámetros actualmente establecidos.</para></listitem>
+                <listitem><para><code>setReturn($type)</code>: Establecer el tipo 
+                    del valor de retorno del servicio.</para></listitem>
+                <listitem><para><code>getReturn()</code>: Obtener el tipo del 
+                    valor de retorno del servicio.</para></listitem>
+                <listitem><para><code>toArray()</code>: Mandar el servicio a un 
+                    array.</para></listitem>
+                <listitem><para><code>toJson()</code>: Mandar el servicio a una 
+                    representación JSON.</para></listitem>
+            </itemizedlist>
+        </sect3>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Json-xml2json.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.json.xml2json">
+    <title>Conversión de XML a JSON</title>
+    <para>
+        <classname>Zend_Json</classname> roporciona una método conveniente para 
+        transformar datos en formato XML a formato JSON. Esta característica fue 
+        inspirado en un 
+        <ulink url="http://www.ibm.com/developerworks/xml/library/x-xml2jsonphp/">
+        artículo de IBM developerWorks</ulink>.
+    </para>
+
+    <para>
+        <classname>Zend_Json</classname> incluye una función estática llamada 
+        <classname>Zend_Json::fromXml()</classname>.
+        Esta función generará JSON desde una determinada entrada XML. 
+        Esta función toma cualquier string XML arbitrario como un parámetro de  
+        entrada. También puede tomar opcionalmente parámetros booleanos de entrada 
+        que instruyan a la lógica de conversión de ignorar o no los atributos 
+        XML durante el proceso de conversión. Si este parámetro opcional de entrada 
+        no está dado, entonces el comportamiento por defecto es ignorar los 
+        atributos XML. 
+        La llamada a esta función se hace como se muestra a continuación:
+    </para>
+    <programlisting role="php"><![CDATA[
+// la función fromXml simplemente toma un string conteniendo XML 
+// como entrada.
+$jsonContents = Zend_Json::fromXml($xmlStringContents, true);
+]]></programlisting>
+
+    <para>
+        <classname>Zend_Json::fromXml()</classname> función que hace la conversión 
+        del parámetro de entrada formateado como un string XML y devuelve el 
+        string de salida equivalente formateado a JSON.  
+        En caso de cualquier entrada con formato XML erróneo o un error en la lógica 
+        de conversión, esta función arrojará una excepción. 
+        La conversión lógica también usa técnicas recursivas para recorrer el 
+        árbol XML. Soporta una recursión de hasta 25 niveles de profundidad. 
+        Más allá de esa profundidad, arrojará una 
+        <classname>Zend_Json_Exception</classname>. Hay varios archivos XML con 
+        diversos grados de complejidad provistas en el directorio de tests de  
+        Zend Framework. Se pueden utilizar para probar la funcionalidad de la 
+        característica xml2json.
+    </para>
+
+    <para>
+        El siguiente es un ejemplo simple que muestra tanto el string de entrada  
+        XML pasado a y al string JSON de salida devuelto como resultado de la 
+        función <classname>Zend_Json::fromXml()</classname>. Este ejemplo utilizó 
+        el parámetro de la función opcional como para no ignorar los atributos 
+        XML durante la conversión. Por lo tanto, puede notar que el string 
+        resultante JSON incluye una representación de los atributos XML presentes 
+        en el string de entrada XML.
+    </para>
+
+    <para>
+        String de entrada XML pasada a la función 
+        <classname>Zend_Json::fromXml()</classname>:
+    </para>
+
+    <programlisting role="php"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<books>
+    <book id="1">
+        <title>Code Generation in Action</title>
+        <author><first>Jack</first><last>Herrington</last></author>
+        <publisher>Manning</publisher>
+    </book>
+
+    <book id="2">
+        <title>PHP Hacks</title>
+        <author><first>Jack</first><last>Herrington</last></author>
+        <publisher>O'Reilly</publisher>
+    </book>
+
+    <book id="3">
+        <title>Podcasting Hacks</title>
+        <author><first>Jack</first><last>Herrington</last></author>
+        <publisher>O'Reilly</publisher>
+    </book>
+</books>
+]]></programlisting>
+
+    <para>
+        String de salida JSON devuelto por la función 
+        <classname>Zend_Json::fromXml()</classname>:
+    </para>
+
+    <programlisting role="php"><![CDATA[
+{
+   "books" : {
+      "book" : [ {
+         "@attributes" : {
+            "id" : "1"
+         },
+         "title" : "Code Generation in Action",
+         "author" : {
+            "first" : "Jack", "last" : "Herrington"
+         },
+         "publisher" : "Manning"
+      }, {
+         "@attributes" : {
+            "id" : "2"
+         },
+         "title" : "PHP Hacks", "author" : {
+            "first" : "Jack", "last" : "Herrington"
+         },
+         "publisher" : "O'Reilly"
+      }, {
+         "@attributes" : {
+            "id" : "3"
+         },
+         "title" : "Podcasting Hacks", "author" : {
+            "first" : "Jack", "last" : "Herrington"
+         },
+         "publisher" : "O'Reilly"
+      }
+   ]}
+}
+]]></programlisting>
+
+    <para>
+        Más detalles sobre esta característica xml2json pueden encontrarse en la 
+        propuesta original. Eche un vistazo a la
+        <ulink url="http://tinyurl.com/2tfa8z">Zend_xml2json proposal</ulink>.
+    </para>
+
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Pdf-Create.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.pdf.create">
+    <title>Creando y Cargando Documentos PDF</title>
+    <para>
+    La clase <classname>Zend_Pdf</classname> representa documentos PDF y 
+    proporciona operaciones a nivel de documento.
+    </para>
+
+    <para>
+    Para crear un nuevo documento, primero debe ser creado un nuevo objeto 
+    <classname>Zend_Pdf</classname>.
+    </para>
+
+    <para>
+    La clase <classname>Zend_Pdf</classname> también ofrece dos métodos estáticos 
+    para cargar un documento PDF.
+    Estos métodos son <classname>Zend_Pdf::load()</classname> y 
+    <classname>Zend_Pdf::parse()</classname>.
+    Ambos retornan objetos <classname>Zend_Pdf</classname> como resultado o 
+    arrojan una excepción si ocurre un error.
+    </para>
+
+    <example id="zend.pdf.create.example-1">
+        <title>Crear un nuevo documento PDF o cargar uno ya esistente.</title>
+        <programlisting role="php"><![CDATA[
+...
+// Crear un nuevo documento PDF
+$pdf1 = new Zend_Pdf();
+
+// Cargar un documento PDF desde un archivo
+$pdf2 = Zend_Pdf::load($fileName);
+
+// Cargar un documento PDF desde un string
+$pdf3 = Zend_Pdf::parse($pdfString);
+...
+]]></programlisting>
+    </example>
+
+    <para>
+    El formato de archivos PDF soporta la actualización incremental del documento.  
+    Así, cada vez que un documento es actualizado, entonces se crea una nueva 
+    revisión del documento.
+    El componente <classname>Zend_Pdf</classname> soporta la recuperación de una 
+    revisión especificada.
+    </para>
+    <para>
+    Una revisión puede especificarse como un segundo parámetro a los métodos  
+    <classname>Zend_Pdf::load()</classname> y <classname>Zend_Pdf::parse()</classname> 
+    o requerirlo llamando al método <classname>Zend_Pdf::rollback()</classname>. 
+        <footnote>
+            <para>
+            El método <classname>Zend_Pdf::rollback()</classname> debe ser invocado 
+            antes de aplicar cualquier cambio al documento, de lo contrario el 
+            comportamiento no está definido.
+            </para>
+        </footnote>
+    call.
+    </para>
+
+    <example id="zend.pdf.create.example-2">
+        <title>Requiriendo Revisiones Específicas de un documento PDF</title>
+        <programlisting role="php"><![CDATA[
+...
+// Cargar la revisión anterior del documento PDF
+$pdf1 = Zend_Pdf::load($fileName, 1);
+
+// Cargar la revisión anterior del documento PDF
+$pdf2 = Zend_Pdf::parse($pdfString, 1);
+
+// Cargar la primera revisión del documento PDF
+$pdf3 = Zend_Pdf::load($fileName);
+$revisions = $pdf3->revisions();
+$pdf3->rollback($revisions - 1);
+...
+]]></programlisting>
+    </example>
+
+
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Pdf-Introduction.xml

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.pdf.introduction">
+    <!-- @todo review and revise upon completion of refactoring -->
+    <title>Introducción</title>
+    <para>
+    El componente <classname>Zend_Pdf</classname> es un motor para manipular
+    documentos PDF (Portable Document Format). 
+    Puede cargar, crear, modificar y guardar documentos. Por lo tanto, puede 
+    ayudar a cualquier aplicación PHP a crear dinámicamente documentos PDF 
+    modificando los documentos existentes o generar unos nuevos desde cero.
+
+    <classname>Zend_Pdf</classname> ofrece las siguientes características:
+    <itemizedlist>
+        <listitem>
+            <para>
+            Crear un documento nuevo o cargar uno existente.
+            <footnote>
+                <para>
+                La carga de documentos PDF V1.4 (Acrobat 5) ahora está soportada.
+                </para>
+            </footnote>
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Recuperar una determinada revisión del documento.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Manipular páginas desde dentro de un documento. Cambiar el orden de 
+            las páginas, añadir nuevas páginas, eliminar páginas de un documento.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Diferentes primitivas de dibujo (líneas, rectángulos, polígonos, 
+            círculos, elipses y sectores).
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Dibujo de texto utilizando alguno de las 14 fuentes estándar 
+            (incorporadas) o sus propias fuentes personalizadas TrueType.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Rotaciones.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Dibujo de imágenes.
+            <footnote>
+                <para>
+                Están soportados los formatos de imagen JPG, PNG 
+                [hasta 8bit por channel+Alpha] y TIFF.
+                </para>
+            </footnote>
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+            Actualización incremental de archivos PDF.
+            </para>
+        </listitem>
+    </itemizedlist>
+    </para>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Pdf-Pages.xml

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.pdf.pages">
+    <title>Trabajando con Páginas</title>
+    <sect2 id="zend.pdf.pages.creation">
+        <title>Creación de Páginas</title>
+        <para>
+             Las páginas en un documento PDF están representadas como instancias 
+             <classname>Zend_Pdf_Page</classname> en <classname>Zend_Pdf</classname>.
+        </para>
+
+        <para>
+            Las páginas PDF o bien son cargadas desde una PDF ya existente o 
+            creadas usando la API <classname>Zend_Pdf</classname>.
+        </para>
+
+        <para>
+            Se pueden crear nuevas páginas instanciando directamente al objeto  
+            <classname>Zend_Pdf_Page</classname> o llamando al método 
+            <classname>Zend_Pdf::newPage()</classname>, que devuelve un objeto  
+            <classname>Zend_Pdf_Page</classname>.
+            <classname>Zend_Pdf::newPage()</classname> crea una página que ya 
+            está agregada a un documento. Las páginas no agregadas no pueden ser 
+            utilizadas con múltiples documentos PDF, pero son algo más eficientes.
+            <footnote>
+                <para>
+                Es una limitación de la versión actual de ZF. Será eliminada en 
+                futuras versiones. Pero las páginas no agregadas siempre dan mejor 
+                resultado (más óptimo) para compartir páginas entre los documentos.
+                </para>
+            </footnote>
+        </para>
+
+        <para>
+        El método <classname>Zend_Pdf::newPage()</classname> y el constructor  
+        <classname>Zend_Pdf_Page</classname> toman los mismos parámetros que 
+        especifican el tamaño de la página. Pueden tomar el tamaño de la 
+        página ($x, $y) en puntos (1/72 pulgadas) o una constante predefinida 
+        representando un tipo de página:
+            <itemizedlist>
+                <listitem>
+                    <para>Zend_Pdf_Page::SIZE_A4</para>
+                </listitem>
+                <listitem>
+                    <para>Zend_Pdf_Page::SIZE_A4_LANDSCAPE</para>
+                </listitem>
+                <listitem>
+                    <para>Zend_Pdf_Page::SIZE_LETTER</para>
+                </listitem>
+                <listitem>
+                    <para>Zend_Pdf_Page::SIZE_LETTER_LANDSCAPE</para>
+                </listitem>
+            </itemizedlist>
+        </para>
+
+        <para>
+            Las páginas del documento se almacenados en el atributo público 
+            <code>$pages</code> de la clase <classname>Zend_Pdf</classname>. 
+            El atributo posee un array de objetos <classname>Zend_Pdf_Page</classname> 
+            y define completamente las instancias y el orden de las páginas. 
+            Este array puede manipularse como cualquie otro array PHP:
+        </para>
+
+        <example id="zend.pdf.pages.example-1">
+            <title>Administración de Páginas de un Documento PDF.</title>
+            <programlisting role="php"><![CDATA[
+...
+// Invertir el orden de las páginas.
+$pdf->pages = array_reverse($pdf->pages);
+...
+// Agregar una nueva página.
+$pdf->pages[] = new Zend_Pdf_Page(Zend_Pdf_Page::SIZE_A4);
+// Agregar una nueva página.
+$pdf->pages[] = $pdf->newPage(Zend_Pdf_Page::SIZE_A4);
+
+// Eliminar la página especificada.
+unset($pdf->pages[$id]);
+
+...
+]]></programlisting>
+        </example>
+    </sect2>
+
+    <sect2 id="zend.pdf.pages.cloning">
+        <title>Clonado de Páfinas.</title>
+        <para>
+            La página PDF existente puede ser clonada creando un nuevo objeto 
+            <classname>Zend_Pdf_Page</classname> con una página existente como 
+            parámetro:
+        </para>
+
+        <example id="zend.pdf.pages.example-2">
+            <title>Clonando una Página Existente.</title>
+            <programlisting role="php"><![CDATA[
+...
+// Almacenar la página plantilla en una variable
+$template = $pdf->pages[$templatePageIndex];
+...
+// Agregar una nueva página.
+$page1 = new Zend_Pdf_Page($template);
+$pdf->pages[] = $page1;
+...
+
+// Agregar otra página.
+$page2 = new Zend_Pdf_Page($template);
+$pdf->pages[] = $page2;
+...
+
+// Eliminar la página fuente de la plantilla de los documentos.
+unset($pdf->pages[$templatePageIndex]);
+
+...
+]]></programlisting>
+        </example>
+
+        <para>
+            Es útil si necesita crear varias páginas utilizando una plantilla.
+        </para>
+
+        <caution>
+            <para>
+                Importante! La página clonada comparte algunos recursos de PDF 
+                con una página plantilla, la que puede ser utilizada sólo en 
+                el mismo documento como una página plantilla. 
+                El documento modificado pueden guardarse como uno nuevo.
+            </para>
+        </caution>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Pdf-Save.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.pdf.save">
+    <title>Guardar Cambios a Documentos PDF</title>
+    <para>
+    Hay dos métodos que guardan los cambios a los documentos PDF:
+    los métodos son <classname>Zend_Pdf::save()</classname> y
+    <classname>Zend_Pdf::render()</classname>.
+    </para>
+
+    <para>
+    <classname>Zend_Pdf::save($filename, $updateOnly = false)</classname> 
+    guarda el documento PDF en un archivo. Si $updateOnly es verdadero, sólo 
+    entonces el nuevo segmento del archivo PDF se agrega al archivo. 
+    De lo contrario, el archivo es sobreescrito.
+    </para>
+
+    <para>
+    <classname>Zend_Pdf::render($newSegmentOnly = false)</classname> 
+    regresa el documento PDF como un string. Si $newSegmentOnly es verdadero, 
+    entonces sólo el nuevo segmento del archivo PDF es devuelto.
+    </para>
+
+    <example id="zend.pdf.save.example-1">
+        <title>Guardando Documentos PDF</title>
+        <programlisting role="php"><![CDATA[
+...
+// Cargar el documento PDF
+$pdf = Zend_Pdf::load($fileName);
+...
+// Actualizar el documento PDF
+$pdf->save($fileName, true);
+// Save document as a new file
+$pdf->save($newFileName);
+
+// Devolver el documento PDF como un string
+$pdfString = $pdf->render();
+
+...
+]]></programlisting>
+    </example>
+
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->