libredte-lib-sdk 0.5.2__tar.gz → 0.6.0__tar.gz

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: libredte-lib-sdk
-Version: 0.5.2
+Version: 0.6.0
 Summary: SDK Python para la API de LibreDTE Lib (facturacion electronica de Chile).
 Project-URL: Homepage, https://www.libredte.cl
 Project-URL: Source, https://github.com/libredte/libredte-lib-sdk-python
@@ -187,14 +187,26 @@ entorno ``LIBREDTE_LIB_SDK_BASE_URL``:
 ``core.libredte.cl`` y ``pro.libredte.cl`` exponen el mismo contrato con
 límites de solicitudes distintos; ambos aceptan la variante ``LibreDTE
 (base_url=..., ...)`` con el resto de los parámetros de configuración
-(``api_token``, ``timeout``, ``http_client``).
+(``api_token``, ``auth_scheme``, ``timeout``, ``http_client``).
 
 Autenticación
 ~~~~~~~~~~~~~
 
 ``LibreDTE(api_token=...)`` o la variable de entorno
 ``LIBREDTE_LIB_SDK_TOKEN`` — si está presente, se manda como header
-``Authorization: Bearer <token>``.
+``Authorization: <esquema> <token>``. El esquema es ``Bearer`` por
+defecto (lo que espera ``core.libredte.cl``/``pro.libredte.cl``);
+configurable con ``LibreDTE(auth_scheme=...)`` o la variable de entorno
+``LIBREDTE_LIB_SDK_AUTH_SCHEME`` para hablar con otra API que use un
+esquema distinto (ej. ``'Token'``):
+
+.. code-block:: python
+
+    sdk = LibreDTE(
+        base_url='https://app.apigateway.cl/api/v2/libredte',
+        api_token='...',
+        auth_scheme='Token',
+    )
 
 Recursos de ``system``
 -----------------------

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/README.rst

@@ -143,14 +143,26 @@ entorno ``LIBREDTE_LIB_SDK_BASE_URL``:
 ``core.libredte.cl`` y ``pro.libredte.cl`` exponen el mismo contrato con
 límites de solicitudes distintos; ambos aceptan la variante ``LibreDTE
 (base_url=..., ...)`` con el resto de los parámetros de configuración
-(``api_token``, ``timeout``, ``http_client``).
+(``api_token``, ``auth_scheme``, ``timeout``, ``http_client``).
 
 Autenticación
 ~~~~~~~~~~~~~
 
 ``LibreDTE(api_token=...)`` o la variable de entorno
 ``LIBREDTE_LIB_SDK_TOKEN`` — si está presente, se manda como header
-``Authorization: Bearer <token>``.
+``Authorization: <esquema> <token>``. El esquema es ``Bearer`` por
+defecto (lo que espera ``core.libredte.cl``/``pro.libredte.cl``);
+configurable con ``LibreDTE(auth_scheme=...)`` o la variable de entorno
+``LIBREDTE_LIB_SDK_AUTH_SCHEME`` para hablar con otra API que use un
+esquema distinto (ej. ``'Token'``):
+
+.. code-block:: python
+
+    sdk = LibreDTE(
+        base_url='https://app.apigateway.cl/api/v2/libredte',
+        api_token='...',
+        auth_scheme='Token',
+    )
 
 Recursos de ``system``
 -----------------------

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/book/builder.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import Any
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from ..trading_parties.models import Certificate
 from .models import BookBag
 
@@ -37,8 +38,8 @@ class BookBuilderService:
         .load()`, acá `BookBag.book` viene poblado (el libro construido
         y firmado, con su `xml`).
         """
-        data = self._client.call(
+        response = self._client.call_response(
             self._BUILD_OPERATION,
             bag={**bag, 'certificate': certificate.to_payload()},
         )
-        return BookBag.from_api(data)
+        return build_response(BookBag, response)

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/book/loader.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import Any
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from ..trading_parties.models import Certificate
 from .models import BookBag
 
@@ -35,8 +36,8 @@ class BookLoaderService:
         el libro); `BookBag.book_auth` viene poblado solo si
         `bag['emisor']` incluye `autorizacion_dte`.
         """
-        data = self._client.call(
+        response = self._client.call_response(
             self._LOAD_OPERATION,
             bag={**bag, 'certificate': certificate.to_payload()},
         )
-        return BookBag.from_api(data)
+        return build_response(BookBag, response)

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/book/models.py

@@ -9,7 +9,12 @@ import base64
 from dataclasses import dataclass
 from typing import Any, cast
 
+from ...response_registry import api_response
 
+
+@api_response(
+    'libredte\\lib\\Core\\Package\\Billing\\Component\\Book\\Support\\BookBag',
+)
 @dataclass(frozen=True, slots=True)
 class BookBag:
     """

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/common.py

@@ -6,6 +6,36 @@
 from __future__ import annotations
 
 import base64
+from typing import Any
+
+
+def encode_content(content: str | bytes) -> str:
+    """
+    Codifica en base64 un contenido para enviarlo a la API.
+
+    Un `bytes` se envía tal cual, sin alterar su codificación (lo correcto
+    para el contenido de un archivo). Un `str` ya es texto decodificado, así
+    que se codifica en UTF-8.
+    """
+    raw = content if isinstance(content, bytes) else content.encode('utf-8')
+
+    return base64.b64encode(raw).decode()
+
+
+def encode_input_data(
+    input_data: str | bytes | dict[str, Any],
+) -> str | dict[str, Any]:
+    """
+    Prepara el `inputData` de una bolsa para enviarlo a la API.
+
+    Un `dict` son los datos en JSON y viaja tal cual. Todo lo demás es el
+    contenido original en otro formato (XML, YAML, texto, etc.) y viaja en
+    base64 (ver `encode_content()`).
+    """
+    if isinstance(input_data, dict):
+        return input_data
+
+    return encode_content(input_data)
 
 
 class XmlPayloadMixin:

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/__init__.py

@@ -6,29 +6,35 @@
 from __future__ import annotations
 
 from ...client import ApiClient
+from .batch_processor import DocumentBatchProcessorService
 from .builder import DocumentBuilderService
 from .dispatcher import DocumentDispatcherService
 from .examples import DocumentExamplesService
 from .loader import DocumentLoaderService
 from .models import (
     DocumentBag,
+    DocumentBatch,
     DocumentEnvelope,
     Example,
     ExampleSummary,
     RenderedDocument,
     RenderResult,
 )
+from .parser import DocumentParserService
 from .renderer import DocumentRendererService
 from .validator import DocumentValidatorService
 
 __all__ = [
     'DocumentBag',
+    'DocumentBatch',
+    'DocumentBatchProcessorService',
     'DocumentBuilderService',
     'DocumentComponent',
     'DocumentDispatcherService',
     'DocumentEnvelope',
     'DocumentExamplesService',
     'DocumentLoaderService',
+    'DocumentParserService',
     'DocumentRendererService',
     'DocumentValidatorService',
     'Example',
@@ -49,3 +55,5 @@ class DocumentComponent:
         self.examples = DocumentExamplesService(client)
         self.validator = DocumentValidatorService(client)
         self.loader = DocumentLoaderService(client)
+        self.parser = DocumentParserService(client)
+        self.batch_processor = DocumentBatchProcessorService(client)

libredte_lib_sdk-0.6.0/libredte_lib_sdk/billing/document/batch_processor.py

@@ -0,0 +1,72 @@
+# Copyright (C) 2026 LibreDTE <https://www.libredte.cl>
+# SPDX-License-Identifier: MIT
+
+"""Servicio para `billing.document.batch_processor`."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...client import ApiClient
+from ...response_registry import build_response
+from ..common import encode_content
+from .models import DocumentBatch
+
+
+class DocumentBatchProcessorService:
+    """
+    Parsea un lote de documentos de una emisión masiva.
+
+    Solo cubre `parse`: entrega los documentos parseados, sin construirlos
+    (sin folios, CAF ni certificado).
+    """
+
+    _PARSE_OPERATION = 'billing.document.batch_processor::parse'
+
+    def __init__(self, client: ApiClient) -> None:
+        """Guarda el `ApiClient` compartido usado para llamar a la API."""
+        self._client = client
+
+    def parse(
+        self,
+        input_data: str | bytes,
+        *,
+        emisor: dict[str, Any] | None = None,
+        strategy: str | None = None,
+        complete: bool | None = None,
+    ) -> DocumentBatch:
+        """
+        Parsea el archivo de un lote y entrega las bolsas de sus documentos.
+
+        `input_data` es el contenido del archivo (CSV, XLSX, etc.). Se debe
+        pasar como `bytes` (leído en modo `rb`): se envía sin alterar. Un
+        `str` ya es texto decodificado y se envía en UTF-8.
+
+        `emisor` es un `dict` con `rut`/`razon_social` (y demás datos del
+        emisor): con `complete` activo (por defecto) se usan para completar
+        los datos del emisor de cada documento.
+
+        `strategy` es la estrategia del archivo (`'spreadsheet.csv'` por
+        defecto; `'spreadsheet.xlsx'` solo existe en Lib Pro). `complete`
+        indica si se completan los datos del documento con los del emisor
+        (por defecto la API lo hace).
+
+        Un error en el archivo lanza `LibreDteApiError` indicando la fila
+        (ej. ``Fila 3: ...``).
+        """
+        batch: dict[str, Any] = {'inputData': encode_content(input_data)}
+        if emisor is not None:
+            batch['emisor'] = emisor
+
+        options: dict[str, Any] = {}
+        if strategy is not None:
+            options['strategy'] = strategy
+        if complete is not None:
+            options['complete'] = complete
+        if options:
+            batch['options'] = {'batch_processor': options}
+
+        return build_response(
+            DocumentBatch,
+            self._client.call_response(self._PARSE_OPERATION, batch=batch),
+        )

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/builder.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 from typing import Any
 
 from ...client import ApiClient
+from ...response_registry import build_response
+from ..common import encode_input_data
 from ..trading_parties.models import Certificate
 from .models import DocumentBag
 
@@ -30,7 +32,7 @@ class DocumentBuilderService:
 
     def build_draft(
         self,
-        input_data: str | dict[str, Any],
+        input_data: str | bytes | dict[str, Any],
         *,
         options: dict[str, Any] | None = None,
     ) -> DocumentBag:
@@ -39,25 +41,28 @@ class DocumentBuilderService:
 
         `input_data` es el `Encabezado`/`Detalle` (y demás nodos) del
         formato DTE del SII como `dict` — o datos en otro formato
-        (XML/YAML, un formulario, etc.) junto con
+        (XML/YAML, un formulario, etc.), como `bytes` o `str`, junto con
         `options={'parser': {'strategy': '<estrategia>'}}` para indicar
-        cómo parsearlos. Sin `options`, la API asume que `input_data` ya
+        cómo parsearlos. El contenido de un archivo se debe pasar como
+        `bytes` (leído en modo `rb`): se envía sin alterar su
+        codificación. Un `str` ya es texto decodificado y se envía en
+        UTF-8. Sin `options`, la API asume que `input_data` ya
         viene en el formato DTE del SII (estrategia `default.json`).
         `Encabezado.IdDoc.Folio` es opcional acá — un borrador sin folio
         no falla (queda con folio `0` en `DocumentBag.document_id`, sin
         nodo `Folio` en el XML). Sin CAF ni certificado, el resultado no
         queda timbrado (`DocumentBag.is_timbrado` es `False`).
         """
-        bag: dict[str, Any] = {'inputData': input_data}
+        bag: dict[str, Any] = {'inputData': encode_input_data(input_data)}
         if options is not None:
             bag['options'] = options
 
-        data = self._client.call(self._BUILD_OPERATION, bag=bag)
-        return DocumentBag.from_api(data)
+        response = self._client.call_response(self._BUILD_OPERATION, bag=bag)
+        return build_response(DocumentBag, response)
 
     def build_signed(
         self,
-        input_data: str | dict[str, Any],
+        input_data: str | bytes | dict[str, Any],
         *,
         options: dict[str, Any] | None = None,
         caf_xml: str,
@@ -75,11 +80,11 @@ class DocumentBuilderService:
         `IdentifierComponent.caf_faker` y
         `TradingPartiesComponent.mandatario_manager`.
         """
-        bag: dict[str, Any] = {'inputData': input_data}
+        bag: dict[str, Any] = {'inputData': encode_input_data(input_data)}
         if options is not None:
             bag['options'] = options
         bag['caf'] = caf_xml
         bag['certificate'] = certificate.to_payload()
 
-        data = self._client.call(self._BUILD_OPERATION, bag=bag)
-        return DocumentBag.from_api(data)
+        response = self._client.call_response(self._BUILD_OPERATION, bag=bag)
+        return build_response(DocumentBag, response)

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/dispatcher.py

@@ -9,6 +9,7 @@ from collections.abc import Sequence
 from typing import Any, cast
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from .models import DocumentBag, DocumentEnvelope
 
 
@@ -37,11 +38,11 @@ class DocumentDispatcherService:
         `emisor` incluidos, no hace falta pasarlos aparte. El sobre
         resultante es lo que se envía al SII (`SiiDteService.send`).
         """
-        data = self._client.call(
+        response = self._client.call_response(
             self._CREATE_OPERATION,
             bag=self._bag_payload(bag),
         )
-        return DocumentEnvelope.from_api(data)
+        return build_response(DocumentEnvelope, response)
 
     def create_many(self, bags: Sequence[DocumentBag]) -> DocumentEnvelope:
         """
@@ -53,11 +54,11 @@ class DocumentDispatcherService:
         del PRIMER `DocumentBag` (el sobre en sí también se firma, no
         solo cada documento).
         """
-        data = self._client.call(
+        response = self._client.call_response(
             self._CREATE_MANY_OPERATION,
             bags=[self._bag_payload(bag) for bag in bags],
         )
-        return DocumentEnvelope.from_api(data)
+        return build_response(DocumentEnvelope, response)
 
     @staticmethod
     def _bag_payload(bag: DocumentBag) -> dict[str, Any]:
@@ -87,8 +88,10 @@ class DocumentDispatcherService:
         más — y en `caratula` los datos de la carátula ya presente en
         ese XML.
         """
-        data = self._client.call(self._LOAD_XML_OPERATION, xml=xml_base64)
-        return DocumentEnvelope.from_api(data)
+        response = self._client.call_response(
+            self._LOAD_XML_OPERATION, xml=xml_base64
+        )
+        return build_response(DocumentEnvelope, response)
 
     def validate(self, source: str) -> dict[str, Any]:
         """

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/loader.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from .models import DocumentBag
 
 
@@ -34,5 +35,7 @@ class DocumentLoaderService:
         acá, `document`/`document_type`/`document_stamp_base64`/etc.
         son el valor agregado real: los datos ya normalizados.
         """
-        data = self._client.call(self._LOAD_XML_OPERATION, xml=xml_base64)
-        return DocumentBag.from_api(data)
+        response = self._client.call_response(
+            self._LOAD_XML_OPERATION, xml=xml_base64
+        )
+        return build_response(DocumentBag, response)

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/models.py

@@ -15,18 +15,25 @@ import base64
 from dataclasses import dataclass
 from typing import Any
 
+from ...response_registry import api_response
 from ..common import XmlPayloadMixin
 from ..identifier.models import Caf
 from ..trading_parties.models import Certificate
 
+_PHP_SUPPORT = (
+    'libredte\\lib\\Core\\Package\\Billing\\Component\\Document\\Support'
+)
 
+
+@api_response(f'{_PHP_SUPPORT}\\DocumentBag')
 @dataclass(frozen=True, slots=True)
 class DocumentBag:
     """
     Bolsa de un documento tributario.
 
-    Devuelta por `document.builder::build`/`document.loader::loadXml`
-    — ambas en esta misma forma. `document`
+    Devuelta por `document.builder::build`/`document.loader::loadXml`/
+    `document.parser::parse` — todas en esta misma forma, con los campos
+    que correspondan a cuánto se hizo con el documento. `document`
     (`Encabezado`/`Detalle`, con el merge de `libredte_data.extra.dte`
     si se pasó al renderizar) es la vista "de datos" limpia del
     documento — SIN los campos opcionales no usados (se omiten, no
@@ -66,13 +73,20 @@ class DocumentBag:
     (`document_stamp_base64` es el mismo dato, pero como XML) — `None`
     si el documento aún no está timbrado.
 
+    Una bolsa que solo se parseó (`DocumentParserService`, o cada bolsa de
+    un `DocumentBatch`) trae `document_parsed` (los datos en el formato
+    DTE del SII, tal como los entregó el parser) y deja en `None` lo que
+    requiere construir el documento: `document`, `document_type`, el XML,
+    etc.
+
     No usa `XmlPayloadMixin`: acá `xml_base64` es una `@property` (el
     documento puede no estar construido), no un campo simple.
     """
 
-    document: dict[str, Any]
+    document: dict[str, Any] | None
+    document_parsed: dict[str, Any] | None
     document_normalized: dict[str, Any] | None
-    document_type: dict[str, Any]
+    document_type: dict[str, Any] | None
     document_stamp_base64: str | None
     document_extra: dict[str, Any] | None
     document_auth: dict[str, Any] | None
@@ -116,9 +130,10 @@ class DocumentBag:
     def from_api(cls, data: dict[str, Any]) -> DocumentBag:
         """Construye un `DocumentBag` desde el `data` de la API."""
         return cls(
-            document=data['document'],
+            document=data.get('document'),
+            document_parsed=data.get('document_parsed'),
             document_normalized=data.get('document_normalized'),
-            document_type=data['document_type'],
+            document_type=data.get('document_type'),
             document_stamp_base64=data.get('document_stamp'),
             document_extra=data.get('document_extra'),
             document_auth=data.get('document_auth'),
@@ -136,6 +151,36 @@ class DocumentBag:
         )
 
 
+@api_response(f'{_PHP_SUPPORT}\\DocumentBatch')
+@dataclass(frozen=True, slots=True)
+class DocumentBatch:
+    """
+    Lote de documentos de una emisión masiva, ya parseado.
+
+    Devuelto por `batch_processor::parse`. `document_bags` trae una bolsa
+    (`DocumentBag`) por cada documento del archivo, en el orden del archivo,
+    con los datos parseados en `document_parsed` — todavía no se construyó
+    ningún documento. No incluye el contenido enviado ni el certificado.
+    """
+
+    document_bags: tuple[DocumentBag, ...]
+    raw: dict[str, Any]
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> DocumentBatch:
+        """Construye un `DocumentBatch` desde el `data` de la API."""
+        return cls(
+            document_bags=tuple(
+                DocumentBag.from_api(item)
+                for item in data.get('document_bags') or []
+            ),
+            raw=data,
+        )
+
+
+@api_response(
+    'libredte\\lib\\Core\\Package\\Billing\\Component\\Document\\Support\\DocumentEnvelope',
+)
 @dataclass(frozen=True, slots=True)
 class DocumentEnvelope(XmlPayloadMixin):
     """
@@ -258,6 +303,9 @@ class Example:
         )
 
 
+@api_response(
+    'libredte\\lib\\Core\\Package\\System\\Component\\Rendering\\Support\\RenderResult',
+)
 @dataclass(frozen=True, slots=True)
 class RenderResult:
     """

libredte_lib_sdk-0.6.0/libredte_lib_sdk/billing/document/parser.py

@@ -0,0 +1,58 @@
+# Copyright (C) 2026 LibreDTE <https://www.libredte.cl>
+# SPDX-License-Identifier: MIT
+
+"""Servicio para `billing.document.parser`."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...client import ApiClient
+from ...response_registry import build_response
+from ..common import encode_input_data
+from .models import DocumentBag
+
+
+class DocumentParserService:
+    """
+    Parsea los datos de entrada de un documento (`billing.document.parser`).
+
+    Solo transforma los datos al formato DTE del SII: no normaliza ni
+    construye el documento, no necesita CAF ni certificado.
+    """
+
+    _PARSE_OPERATION = 'billing.document.parser::parse'
+
+    def __init__(self, client: ApiClient) -> None:
+        """Guarda el `ApiClient` compartido usado para llamar a la API."""
+        self._client = client
+
+    def parse(
+        self,
+        input_data: str | bytes | dict[str, Any],
+        *,
+        strategy: str | None = None,
+    ) -> DocumentBag:
+        """
+        Parsea `input_data` y entrega la bolsa con los datos parseados.
+
+        `input_data` es el documento en el formato DTE del SII como `dict`,
+        o datos en otro formato (XML, YAML, un formulario, etc.) como `bytes`
+        o `str`. El contenido de un archivo se debe pasar como `bytes` (leído
+        en modo `rb`): se envía sin alterar su codificación. Un `str` ya es
+        texto decodificado y se envía en UTF-8.
+
+        `strategy` es la estrategia de parseo (ej. `'default.xml'`,
+        `'form.lite'`); sin ella la API asume `default.json`.
+
+        El resultado es una `DocumentBag` con `document_parsed`; `document`,
+        `document_type` y el XML quedan en `None`.
+        """
+        bag: dict[str, Any] = {'inputData': encode_input_data(input_data)}
+        if strategy is not None:
+            bag['options'] = {'parser': {'strategy': strategy}}
+
+        return build_response(
+            DocumentBag,
+            self._client.call_response(self._PARSE_OPERATION, bag=bag),
+        )

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/document/renderer.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import Any
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from .models import RenderResult
 
 
@@ -68,5 +69,5 @@ class DocumentRendererService:
         if libredte_data is not None:
             bag['libredteData'] = libredte_data
 
-        data = self._client.call(self._RENDER_OPERATION, bag=bag)
-        return RenderResult.from_api(data)
+        response = self._client.call_response(self._RENDER_OPERATION, bag=bag)
+        return build_response(RenderResult, response)

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/exchange/document_response.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import Any, cast
 
 from ...client import ApiClient
+from ...response_registry import build_response
 from ..trading_parties.models import Certificate
 from .models import EnvioRecibos, RespuestaEnvio
 
@@ -53,7 +54,7 @@ class DocumentResponseService:
         `MntTotal`/`Recinto`, y opcionalmente `RutFirma`/`Declaracion`).
         `caratula` trae `RutResponde`/`RutRecibe`.
         """
-        data = self._client.call(
+        response = self._client.call_response(
             self._BUILD_ENVIO_RECIBOS_OPERATION,
             bag={
                 'tipo': 'envio_recibos',
@@ -62,7 +63,7 @@ class DocumentResponseService:
                 'certificate': certificate.to_payload(),
             },
         )
-        return EnvioRecibos.from_api(data)
+        return build_response(EnvioRecibos, response)
 
     def build_respuesta_envio(
         self,
@@ -78,7 +79,7 @@ class DocumentResponseService:
         cual el formato SII. `caratula` trae `RutResponde`/`RutRecibe`/
         `IdRespuesta`.
         """
-        result = self._client.call(
+        response = self._client.call_response(
             self._BUILD_RESPUESTA_ENVIO_OPERATION,
             bag={
                 'tipo': 'respuesta_envio',
@@ -87,7 +88,7 @@ class DocumentResponseService:
                 'certificate': certificate.to_payload(),
             },
         )
-        return RespuestaEnvio.from_api(result)
+        return build_response(RespuestaEnvio, response)
 
     def validate_schema(self, source: str) -> dict[str, Any]:
         """

{libredte_lib_sdk-0.5.2 → libredte_lib_sdk-0.6.0}/libredte_lib_sdk/billing/exchange/models.py

@@ -8,9 +8,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
+from ...response_registry import api_response
 from ..common import XmlPayloadMixin
 
 
+@api_response(
+    'libredte\\lib\\Core\\Package\\Billing\\Component\\Exchange\\Entity\\EnvioRecibos',
+)
 @dataclass(frozen=True, slots=True)
 class EnvioRecibos(XmlPayloadMixin):
     """
@@ -33,6 +37,9 @@ class EnvioRecibos(XmlPayloadMixin):
         )
 
 
+@api_response(
+    'libredte\\lib\\Core\\Package\\Billing\\Component\\Exchange\\Entity\\RespuestaEnvio',
+)
 @dataclass(frozen=True, slots=True)
 class RespuestaEnvio(XmlPayloadMixin):
     """