apacuana-sdk-core 0.9.0 → 0.11.0

package/README.md

@@ -2,7 +2,39 @@
 
 ## Descripción
 
-Apacuana SDK Core es una biblioteca JavaScript que proporciona una interfaz para interactuar con los servicios de Apacuana, permitiendo la generación de certificados digitales, verificación de estados, revocaciones y firma de documentos.
+Apacuana SDK Core es una biblioteca de JavaScript que proporciona una interfaz para interactuar con los servicios de Apacuana, permitiendo la generación de certificados digitales, firma de documentos, y otras operaciones relacionadas con la identidad digital.
+
+## Tabla de Contenidos
+
+- [Instalación](#instalación)
+- [Inicialización](#inicialización)
+- [Conceptos Clave](#conceptos-clave)
+  - [Tipos de Integración](#tipos-de-integración)
+- [Interfaz Pública](#interfaz-pública)
+  - [`init(config)`](#initconfig)
+  - [`close()`](#close)
+  - [`getConfig()`](#getconfig)
+  - [`getCustomer()`](#getcustomer)
+  - [`generateCert(encryptedCSR)`](#generatecertencryptedcsr)
+  - [`getCertStatus(isCertificateInDevice)`](#getcertstatusiscertificateindevice)
+  - [`getCertTypes()`](#getcerttypes)
+  - [`getRequerimentsByTypeUser(params)`](#getrequerimentsbytypeuserparams)
+  - [`requestCertificate(params)`](#requestcertificateparams)
+  - [`addSigner(signerData)`](#addsignersignerdata)
+  - [`getDocs(data)`](#getdocsdata)
+  - [`getDigest(signData)`](#getdigestsigndata)
+  - [`signDocument(signData)`](#signdocumentsigndata)
+  - [`uploadSignatureVariant(data)`](#uploadsignaturevariantdata)
+  - [`getSignatureVariant()`](#getsignaturevariant)
+  - [`deleteSignatureVariant()`](#deletesignaturevariant)
+  - [`createFaceLivenessSession()`](#createfacelivenesssession)
+  - [`requestRevocation(params)`](#requestrevocationparams)
+  - [`getRevocationReasons()`](#getrevocationreasons)
+- [Manejo de Errores](#manejo-de-errores)
+  - [`ApacuanaSuccess`](#apacuanasuccess)
+  - [`ApacuanaAPIError`](#apacuanaapierror)
+  - [Listado de Códigos de Error](#listado-de-códigos-de-error)
+- [Licencia](#licencia)
 
 ## Instalación
 
@@ -10,377 +42,429 @@ Apacuana SDK Core es una biblioteca JavaScript que proporciona una interfaz para
 npm install apacuana-sdk-core
 ```
 
-## Requisitos
+## Inicialización
 
-- Node.js 12 o superior
-- Acceso a las credenciales de API de Apacuana (apiKey y secretKey)
+Antes de utilizar el SDK, debes inicializarlo con tu configuración.
 
-## Configuración Inicial
+```javascript
+import apacuana from "apacuana-sdk-core";
 
-Antes de utilizar cualquier funcionalidad del SDK, es necesario inicializarlo con la configuración adecuada:
+const config = {
+  apiUrl: "https://api.url",
+  secretKey: "tu-secret-key",
+  apiKey: "tu-api-key",
+  verificationId: "tu-verification-id",
+  customerId: "tu-customer-id",
+  integrationType: "ONBOARDING", // o "ONPREMISE"
+};
 
-```javascript
-const apacuana = require("apacuana-sdk-core");
-
-// Configuración inicial
-await apacuana.init({
-  apiUrl: "https://api.apacuana.com",
-  secretKey: "YOUR_SECRET_KEY",
-  apiKey: "YOUR_API_KEY",
-  verificationId: "VERIFICATION_ID",
-  customerId: "CUSTOMER_ID",
-  integrationType: "ONBOARDING",
-});
+try {
+  await apacuana.init(config);
+  console.log("SDK inicializado correctamente.");
+} catch (error) {
+  console.error("Error al inicializar el SDK:", error);
+}
 ```
 
-## Métodos Públicos
+## Conceptos Clave
+
+### Tipos de Integración
 
-### init(config)
+El SDK soporta dos tipos de integración (`integrationType`) que determinan cómo se interactúa con la plataforma de Apacuana:
 
-Inicializa el SDK con la configuración proporcionada.
+- **`ONBOARDING`**: En este modo, Apacuana gestiona la mayor parte del proceso, como el registro de usuarios y la generación de certificados. Es el modo recomendado y soportado para la mayoría de las integraciones.
+- **`ONPREMISE`**: Este modo de integración no está soportado actualmente y se reserva para uso futuro. La mayoría de las operaciones del SDK lanzarán un error `NOT_IMPLEMENTED` si se utiliza este tipo.
 
-**Parámetros:**
+La elección del `integrationType` en la `init` es fundamental, ya que afecta a la disponibilidad y el comportamiento de muchos de los métodos del SDK.
 
-- `config` (Object): Objeto de configuración con las siguientes propiedades:
-  - `apiUrl` (String): URL base de la API de Apacuana
-  - `secretKey` (String): Clave secreta para autenticación
-  - `apiKey` (String): Clave de API para autenticación
-  - `verificationId` (String): ID de verificación
-  - `customerId` (String): ID del cliente
-  - `integrationType` (String): Tipo de integración (ver sección de Tipos de Integración)
+## Interfaz Pública
 
-**Retorna:**
+Todas las funciones asíncronas devuelven una instancia de `ApacuanaSuccess` si tienen éxito, o lanzan una `ApacuanaAPIError` si fallan.
 
-- `Promise<boolean>` que se resuelve a `true` cuando la inicialización es exitosa.
+### `init(config)`
 
-### close()
+Inicializa el SDK.
 
-Cierra la sesión actual del SDK y restablece la configuración a sus valores por defecto, dejando la instancia lista para una nueva inicialización.
+- **`config`**: Objeto de configuración.
 
-**Parámetros:** Ninguno
+### `close()`
 
-**Retorna:** Nada
+Cierra la sesión del SDK y limpia la configuración.
 
 **Ejemplo:**
 
 ```javascript
 apacuana.close();
-console.log("La sesión del SDK ha sido cerrada.");
+console.log("Sesión del SDK cerrada.");
 ```
 
-### getConfig()
-
-Obtiene la configuración actual del SDK.
-
-**Parámetros:** Ninguno
+### `getConfig()`
 
-**Retorna:**
+Devuelve la configuración actual.
 
-- `Object`: Configuración actual del SDK
-
-### getCustomer()
-
-Obtiene la información del cliente utilizando los datos de configuración.
-
-**Parámetros:** Ninguno
-
-**Retorna:**
-
-- `Promise<GetCustomerResponse>` que se resuelve con un objeto que contiene:
-  - `token` (String): ID de sesión para autenticación.
-  - `userData` (Object): Datos del usuario.
-  - `success` (Boolean): Indicador de éxito de la operación.
+**Ejemplo:**
 
-### generateCert(encryptedCSR)
+```javascript
+const currentConfig = apacuana.getConfig();
+console.log("Configuración actual:", currentConfig);
+```
 
-Genera un certificado digital. El comportamiento y el parámetro esperado varían según el `integrationType`.
+### `getCustomer()`
 
-**Parámetros:**
+Obtiene los datos del cliente.
 
-- `encryptedCSR` (`EncryptedCSRObject`): Un objeto que contiene la Solicitud de Firma de Certificado (CSR) encriptada.
-  - `csr` (String): La CSR en formato Base64.
+**Ejemplo:**
 
-**Comportamiento por `integrationType`:**
+```javascript
+try {
+  const response = await apacuana.getCustomer();
+  console.log("Datos del cliente:", response.data);
+} catch (error) {
+  console.error("Error al obtener el cliente:", error.message);
+}
+```
 
-- **`ONBOARDING`**: Valida la CSR y la envía a la API para su registro.
-- **`ONPREMISE`**: No soportado. Lanza una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+### `generateCert(encryptedCSR)`
 
-**Retorna:**
+Genera un nuevo certificado digital.
 
-- `Promise<GenerateCertResponse>` que se resuelve con un objeto que contiene:
-  - `cert` (String): El certificado generado.
-  - `success` (Boolean): Indicador de éxito de la operación.
+- **`encryptedCSR`**: Objeto con la CSR encriptada.
 
 **Ejemplo:**
 
 ```javascript
-const myCsrObject = { csr: "MIIC...==" };
-
 try {
-  const { cert, success } = await apacuana.generateCert(myCsrObject);
-  if (success) {
-    console.log("Certificado generado exitosamente:", cert);
-  }
+  const csr = { csr: "MIIC...==" }; // CSR en formato Base64
+  const response = await apacuana.generateCert(csr);
+  console.log("Certificado generado:", response.data);
 } catch (error) {
   console.error("Error al generar el certificado:", error.message);
 }
 ```
 
-### getCertStatus(isCertificateInDevice)
-
-Obtiene el estado actual del certificado del usuario.
+### `getCertStatus(isCertificateInDevice)`
 
-**Parámetros:**
+Obtiene el estado del certificado del usuario.
 
-- `isCertificateInDevice` (Boolean, opcional): Indica si el certificado ya se encuentra en el dispositivo. Por defecto es `false`.
+- **`isCertificateInDevice`**: Booleano que indica si el certificado está en el dispositivo.
 
-**Retorna:**
+**Ejemplo:**
 
-- `GetCertStatusResponse`: Un objeto que contiene:
-  - `status` (String): El estado del certificado (ver sección de Estados de Certificado).
-  - `success` (Boolean): Indicador de éxito de la operación.
+```javascript
+try {
+  const response = await apacuana.getCertStatus(false);
+  console.log("Estado del certificado:", response.data);
+} catch (error) {
+  console.error("Error al obtener el estado del certificado:", error.message);
+}
+```
 
-### addSigner(signerData)
+### `getCertTypes()`
 
-Agrega un firmante a un documento. El comportamiento y la estructura del objeto `signerData` varían según el `integrationType`.
+Obtiene los tipos de certificados disponibles.
 
-**Parámetros:**
+**Ejemplo:**
 
-- `signerData` (`OnboardingSignerData` | `object`): Un objeto que contiene la información del firmante.
+```javascript
+try {
+  const response = await apacuana.getCertTypes();
+  console.log("Tipos de certificados:", response.data);
+} catch (error) {
+  console.error("Error al obtener los tipos de certificado:", error.message);
+}
+```
 
----
+### `getRequerimentsByTypeUser(params)`
 
-#### Flujo de Integración: ONBOARDING
+Obtiene los requisitos para un tipo de usuario.
 
-Para el tipo de integración `ONBOARDING`, la función espera un objeto `signerData` con una estructura específica y realiza validaciones estrictas sobre cada campo.
+- **`params`**: Objeto con la propiedad `type` (numérico).
 
-**Estructura de `signerData` para ONBOARDING:**
+**Ejemplo:**
 
-```json
-{
-  "name": "Nombre del Documento",
-  "reference": "Referencia Externa",
-  "typedoc": "V",
-  "doc": "26122862",
-  "signature": [
-    {
-      "page": 1,
-      "x": 0.5,
-      "y": 0.85
-    }
-  ]
+```javascript
+try {
+  const response = await apacuana.getRequerimentsByTypeUser({ type: 1 });
+  console.log("Requisitos:", response.data);
+} catch (error) {
+  console.error("Error al obtener los requisitos:", error.message);
 }
 ```
 
-**Campos de `signerData`:**
+### `requestCertificate(params)`
 
-- **`name`** (`string`, requerido): Nombre del documento.
-- **`reference`** (`string`, requerido): Referencia externa del documento en el gestor documental.
-- **`typedoc`** (`string`, requerido): Tipo de documento de identidad. Valores permitidos: `V`, `P`, `E`.
-- **`doc`** (`string`, requerido): Número del documento de identidad.
-- **`signature`** (`Array<SignaturePosition>`, requerido): Un array de objetos que definen la posición de la firma.
-  - **`page`** (`number`, requerido): Número de página (entero positivo).
-  - **`x`** (`number`, requerido): Coordenada X (entre 0 y 1).
-  - **`y`** (`number`, requerido): Coordenada Y (entre 0 y 1).
+Solicita un certificado.
 
----
+- **`params`**: Objeto con las propiedades `type` (numérico) y `documents` (array).
 
-#### Flujo de Integración: ONPREMISE
+**Ejemplo:**
+
+```javascript
+try {
+  const params = { type: 1, documents: ["doc1.pdf", "doc2.pdf"] };
+  const response = await apacuana.requestCertificate(params);
+  console.log("Solicitud de certificado enviada:", response.data);
+} catch (error) {
+  console.error("Error al solicitar el certificado:", error.message);
+}
+```
 
-Esta funcionalidad aún no está implementada para el tipo de integración `ONPREMISE`. Invocar `addSigner` en este modo lanzará una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+### `addSigner(signerData)`
 
----
+Añade un firmante a un documento.
 
-**Retorna:**
+- **`signerData`**: Objeto con los datos del firmante.
 
-- `Promise<AddSignerResponse>` que se resuelve con un objeto que contiene:
-  - `signer` (String): Un identificador del firmante, construido a partir de `typedoc` y `doc`.
-  - `success` (Boolean): Indicador de éxito de la operación.
+**Ejemplo:**
 
-### getDigest(signData)
+```javascript
+try {
+  const signer = {
+    name: "Contrato",
+    reference: "REF-001",
+    typedoc: "V",
+    doc: "12345678",
+    signature: [{ page: 1, x: 0.5, y: 0.5 }],
+  };
+  const response = await apacuana.addSigner(signer);
+  console.log("Firmante añadido:", response.data);
+} catch (error) {
+  console.error("Error al añadir firmante:", error.message);
+}
+```
 
-Obtiene el `digest` de un documento que se va a firmar. Este `digest` es un resumen criptográfico del documento que luego debe ser firmado por el cliente.
+### `getDocs(data)`
 
-**Parámetros:**
+Obtiene una lista paginada de documentos.
 
-- `signData` (`GetDigestData`): Objeto que contiene los datos para la firma.
-  - `cert` (String): Certificado del firmante en formato PEM (codificado en base64).
-  - `signatureId` (String): Identificador único del proceso de firma.
+- **`data`**: Objeto con parámetros de paginación (`page`, `size`) y filtro (`status`).
 
-**Retorna:**
+**Ejemplo:**
 
-- `Promise<GetDigestResponse>`: Un objeto que contiene:
-  - `digest` (String): El digest del documento a firmar.
-  - `success` (Boolean): Indicador de éxito de la operación.
+```javascript
+try {
+  const params = { page: 1, size: 10, status: 0 };
+  const response = await apacuana.getDocs(params);
+  console.log("Documentos:", response.data);
+} catch (error) {
+  console.error("Error al obtener los documentos:", error.message);
+}
+```
 
-### signDocument(signData)
+### `getDigest(signData)`
 
-Firma un documento utilizando un certificado digital y un digest previamente firmado. Esta función es compatible únicamente con el flujo de integración `ONBOARDING`.
+Obtiene el digest de un documento para ser firmado.
 
-**Parámetros:**
+- **`signData`**: Objeto con `cert` y `signatureId`.
 
-- `signData` (`SignDocumentData`): Un objeto que contiene los datos necesarios para la firma.
-  - `signature` (Object): Objeto con información de la firma.
-    - `id` (String): ID de la firma.
-    - `positions` (Array<Object>): Posiciones de la firma en el documento.
-  - `cert` (String): El certificado del firmante en formato base64.
-  - `signedDigest` (String): El digest del documento, ya firmado.
+**Ejemplo:**
 
-**Retorna:**
+```javascript
+try {
+  const params = { cert: "MIIC...==", signatureId: "sig-123" };
+  const response = await apacuana.getDigest(params);
+  console.log("Digest del documento:", response.data);
+} catch (error) {
+  console.error("Error al obtener el digest:", error.message);
+}
+```
 
-- `Promise<object>`: Una promesa que se resuelve con la respuesta de la API tras completar la firma.
+### `signDocument(signData)`
 
-### requestRevocation(reasonCode)
+Firma un documento.
 
-Solicita la revocación de un certificado.
+- **`signData`**: Objeto con `signature`, `cert` y `signedDigest`.
 
-**Parámetros:**
+**Ejemplo:**
 
-- `reasonCode` (String): Código que indica la razón de la revocación (ej. "COMPROMISED").
+```javascript
+try {
+  const params = {
+    signature: { id: "sig-123" },
+    cert: "MIIC...==",
+    signedDigest: "abc...",
+  };
+  const response = await apacuana.signDocument(params);
+  console.log("Documento firmado:", response.data);
+} catch (error) {
+  console.error("Error al firmar el documento:", error.message);
+}
+```
 
-**Retorna:**
+### `uploadSignatureVariant(data)`
 
-- `Promise<RequestRevocationResponse>` que se resuelve con un objeto que contiene:
-  - `revocationStatus` (String): El estado de la solicitud (ej. "pending").
-  - `requestId` (String | Number): El ID de la solicitud de revocación.
+Sube una imagen de firma.
 
-### getRevocationReasons()
+- **`data`**: Objeto con la propiedad `file` (instancia de `File`, tipo `image/png`).
 
-Obtiene la lista de códigos de motivo de revocación disponibles que se pueden usar en la función `requestRevocation`.
+**Ejemplo:**
 
-**Parámetros:** Ninguno
+```javascript
+// Este código se ejecutaría en un entorno de navegador
+const imageFile = new File(["..."], "firma.png", { type: "image/png" });
+try {
+  const response = await apacuana.uploadSignatureVariant({ file: imageFile });
+  console.log(response.data);
+} catch (error) {
+  console.error("Error al subir la firma:", error.message);
+}
+```
 
-**Retorna:**
+### `getSignatureVariant()`
 
-- `Promise<RevocationReasonsResponse>`: Un objeto que contiene:
-  - `reasons` (Array<Object>): Un array de objetos, donde cada objeto representa un motivo de revocación con `code` y `description`.
-  - `success` (Boolean): Indicador de éxito de la operación.
+Obtiene la imagen de la firma del usuario.
 
-**Comportamiento por `integrationType`:**
+**Ejemplo:**
 
-- **`ONBOARDING`**: Obtiene la lista de motivos desde la API.
-- **`ONPREMISE`**: No soportado. Lanza una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+```javascript
+try {
+  const response = await apacuana.getSignatureVariant();
+  // La imagen viene en Base64
+  console.log("Firma obtenida (Base64):", response.data);
+} catch (error) {
+  console.error("Error al obtener la firma:", error.message);
+}
+```
 
-### uploadSignatureVariant(data)
+### `deleteSignatureVariant()`
 
-Sube una variante de firma (imagen) para un firmante específico. Esta imagen se utilizará como la representación gráfica de la firma en los documentos.
+Elimina la imagen de la firma del usuario.
 
-**Parámetros:**
+**Ejemplo:**
 
-- `data` (`UploadSignatureVariantData`): Objeto que contiene los datos para la subida.
-  - `file` (`File`): El archivo de imagen de la firma. Debe ser una instancia de `File` y de tipo `image/png`.
-  - `signerId` (`string`): El identificador del firmante al que se asociará la imagen.
+```javascript
+try {
+  const response = await apacuana.deleteSignatureVariant();
+  console.log(response.data);
+} catch (error) {
+  console.error("Error al eliminar la firma:", error.message);
+}
+```
 
-**Retorna:**
+### `createFaceLivenessSession()`
 
-- `Promise<UploadSignatureVariantResponse>`: Un objeto que contiene:
-  - `message` (String): Un mensaje de confirmación.
-  - `success` (Boolean): Indicador de éxito de la operación.
+Crea una sesión de prueba de vida.
 
-**Comportamiento por `integrationType`:**
+**Ejemplo:**
 
-- **`ONBOARDING`**: Sube el archivo a la API.
-- **`ONPREMISE`**: No soportado. Lanza una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+```javascript
+try {
+  const response = await apacuana.createFaceLivenessSession();
+  console.log("ID de sesión de prueba de vida:", response.data);
+} catch (error) {
+  console.error("Error al crear la sesión:", error.message);
+}
+```
 
-### getSignatureVariant()
+### `requestRevocation(params)`
 
-Obtiene la variante de firma (imagen) de un firmante.
+Solicita la revocación de un certificado.
 
-**Parámetros:** Ninguno
+- **`params`**: Objeto con la propiedad `reasonCode` (numérico).
 
-**Retorna:**
+**Ejemplo:**
 
-- `Promise<GetSignatureVariantResponse>`: Un objeto que contiene:
-  - `file` (String): La imagen de la firma en formato base64.
-  - `success` (Boolean): Indicador de éxito de la operación.
+```javascript
+try {
+  const response = await apacuana.requestRevocation({ reasonCode: 1 });
+  console.log("Solicitud de revocación enviada:", response.data);
+} catch (error) {
+  console.error("Error al solicitar la revocación:", error.message);
+}
+```
 
-**Comportamiento por `integrationType`:**
+### `getRevocationReasons()`
 
-- **`ONBOARDING`**: Realiza una petición `GET` para obtener la imagen.
-- **`ONPREMISE`**: No soportado. Lanza una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+Obtiene la lista de razones para la revocación.
 
 **Ejemplo:**
 
 ```javascript
 try {
-  const { file, success } = await apacuana.getSignatureVariant();
-  if (success) {
-    console.log("Imagen de la firma obtenida.");
-    // Puedes usar 'file' para mostrar la imagen, por ejemplo:
-    // const img = document.createElement('img');
-    // img.src = `data:image/png;base64,${file}`;
-    // document.body.appendChild(img);
-  }
+  const response = await apacuana.getRevocationReasons();
+  console.log("Razones de revocación:", response.data);
 } catch (error) {
-  console.error("Error al obtener la variante de firma:", error.message);
+  console.error("Error al obtener las razones de revocación:", error.message);
 }
 ```
 
-### deleteSignatureVariant()
-
-Elimina la variante de firma (imagen) de un firmante.
+## Manejo de Errores
 
-**Parámetros:** Ninguno
+El SDK utiliza dos clases personalizadas para gestionar los resultados de las operaciones asíncronas: `ApacuanaSuccess` para éxitos y `ApacuanaAPIError` para fallos.
 
-**Retorna:**
+### `ApacuanaSuccess`
 
-- `Promise<DeleteSignatureVariantResponse>`: Un objeto que contiene:
-  - `message` (String): Un mensaje de confirmación.
-  - `success` (Boolean): Indicador de éxito de la operación.
+Cuando una operación se completa correctamente, la promesa se resuelve con una instancia de `ApacuanaSuccess`. Esta clase encapsula la respuesta de la API y proporciona una estructura consistente para los datos devueltos.
 
-**Comportamiento por `integrationType`:**
+**Propiedades:**
 
-- **`ONBOARDING`**: Realiza una petición `DELETE` para eliminar la imagen.
-- **`ONPREMISE`**: No soportado. Lanza una `ApacuanaAPIError` con el código `NOT_IMPLEMENTED`.
+- `success` (Boolean): Siempre `true`.
+- `statusCode` (Number): El código de estado HTTP de la respuesta (ej. `200`).
+- `data` (Object): El cuerpo de la respuesta de la API.
 
-**Ejemplo:**
+**Ejemplo de uso:**
 
 ```javascript
 try {
-  const { message, success } = await apacuana.deleteSignatureVariant();
-  if (success) {
-    console.log(message); // "Signature variant deleted successfully."
-  }
+  // getCertTypes devuelve una instancia de ApacuanaSuccess
+  const response = await apacuana.getCertTypes();
+
+  console.log("La operación fue exitosa:", response.success); // true
+  console.log("Tipos de certificados:", response.data);
 } catch (error) {
-  console.error("Error al eliminar la variante de firma:", error.message);
+  // Manejo de errores (ver abajo)
+  console.error(error);
 }
 ```
 
-### getDocs(data)
-
-Obtiene una lista de documentos paginada.
-
-**Parámetros:**
-
-- `data` (`GetDocsParams`): Objeto que contiene los parámetros para la consulta.
-  - `page` (Number): Número de página.
-  - `size` (Number): Cantidad de resultados por página.
-  - `status` (Number, opcional): Filtra por estado (`-1`: Rechazado, `0`: Pendiente, `1`: Firmado, `2`: En proceso).
+### `ApacuanaAPIError`
 
-**Retorna:**
+Cuando la API devuelve un error o ocurre un problema durante la solicitud, la promesa es rechazada con una instancia de `ApacuanaAPIError`. Esta clase extiende el `Error` nativo de JavaScript y añade información contextual sobre el fallo.
 
-- `Promise<GetDocsResponse>`: Un objeto que contiene:
-  - `totalRecords` (Number): El número total de documentos.
-  - `records` (Array<Object>): Un array de documentos.
-  - `success` (Boolean): Indicador de éxito de la operación.
+**Propiedades:**
 
-## Estados de Certificado
+- `success` (Boolean): Siempre `false`.
+- `statusCode` (Number): El código de estado HTTP del error (ej. `400`, `404`, `500`).
+- `errorCode` (String): Un código de error específico de Apacuana (ej. `INVALID_PARAMS`, `NOT_IMPLEMENTED`).
+- `message` (String): Una descripción legible del error.
 
-- `PENDING`: Pendiente de generación.
-- `ACTIVE`: Activo y listo para usar.
-- `EXPIRED`: Caducado.
-- `REVOKED`: Revocado.
-- `SUSPENDED`: Suspendido temporalmente.
+**Ejemplo de manejo de errores:**
 
-## Tipos de Integración
+```javascript
+try {
+  // Forzamos un error pasando parámetros inválidos
+  await apacuana.requestCertificate({ type: 999, documents: [] });
+} catch (error) {
+  if (error.name === "ApacuanaAPIError") {
+    console.error("Ocurrió un error de la API de Apacuana:");
+    console.error("- Mensaje:", error.message);
+    console.error("- Código de estado HTTP:", error.statusCode);
+    console.error("- Código de error interno:", error.errorCode);
+  } else {
+    // Captura de otros errores inesperados (ej. problemas de red)
+    console.error("Ocurrió un error inesperado:", error);
+  }
+}
+```
 
-- `ONBOARDING`: Proceso de registro y generación de certificado gestionado por Apacuana.
-- `ONPREMISE`: Integración donde el cliente gestiona su propia infraestructura.
+### Listado de Códigos de Error
 
-## Manejo de Errores
+A continuación se muestra una lista de los `errorCode` más comunes que puede devolver el SDK:
 
-El SDK utiliza la clase `ApacuanaAPIError` para manejar errores específicos de la API, la cual extiende `Error` y añade las propiedades `code` y `details`.
+| `errorCode`                    | Descripción                                                             |
+| :----------------------------- | :---------------------------------------------------------------------- |
+| `CONFIGURATION_ERROR`          | Error en la configuración del SDK (ej. falta `apiKey`).                 |
+| `INVALID_API_RESPONSE`         | La respuesta de la API no tiene el formato esperado.                    |
+| `INVALID_PARAMETER`            | Uno o más parámetros de la función son inválidos.                       |
+| `INVALID_PARAMETER_FORMAT`     | El formato de un parámetro es incorrecto.                               |
+| `LOGICAL_API_ERROR`            | Error lógico devuelto por la API.                                       |
+| `NETWORK_ERROR`                | Error de red, CORS o timeout.                                           |
+| `NOT_IMPLEMENTED`              | La funcionalidad no está implementada para el `integrationType` actual. |
+| `UNSUPPORTED_HTTP_METHOD`      | Se utilizó un método HTTP no soportado.                                 |
+| `UNSUPPORTED_INTEGRATION_TYPE` | El `integrationType` no es válido.                                      |
+| `UNKNOWN_REQUEST_ERROR`        | Error desconocido durante la petición.                                  |
+| `API_RESPONSE_ERROR`           | La respuesta de la API contiene un error.                               |
 
 ## Licencia
 
-Este SDK está licenciado bajo términos propietarios.
+Este SDK está distribuido bajo una licencia propietaria. Para más detalles, contacte con el equipo de Apacuana.