factpulse 1.0.9__py3-none-any.whl → 3.0.7__py3-none-any.whl

factpulse/api/{signature_lectronique_api.py → document_conversion_api.py}

@@ -1,9 +1,9 @@
 # coding: utf-8
 
 """
-    API REST FactPulse
+    FactPulse REST API
 
-     API REST pour la facturation électronique en France : Factur-X, AFNOR PDP/PA, signatures électroniques.  ## 🎯 Fonctionnalités principales  ### 📄 Génération de factures Factur-X - **Formats** : XML seul ou PDF/A-3 avec XML embarqué - **Profils** : MINIMUM, BASIC, EN16931, EXTENDED - **Normes** : EN 16931 (directive UE 2014/55), ISO 19005-3 (PDF/A-3), CII (UN/CEFACT) - **🆕 Format simplifié** : Génération à partir de SIRET + auto-enrichissement (API Chorus Pro + Recherche Entreprises)  ### ✅ Validation et conformité - **Validation XML** : Schematron (45 à 210+ règles selon profil) - **Validation PDF** : PDF/A-3, métadonnées XMP Factur-X, signatures électroniques - **VeraPDF** : Validation stricte PDF/A (146+ règles ISO 19005-3) - **Traitement asynchrone** : Support Celery pour validations lourdes (VeraPDF)  ### 📡 Intégration AFNOR PDP/PA (XP Z12-013) - **Soumission de flux** : Envoi de factures vers Plateformes de Dématérialisation Partenaires - **Recherche de flux** : Consultation des factures soumises - **Téléchargement** : Récupération des PDF/A-3 avec XML - **Directory Service** : Recherche d'entreprises (SIREN/SIRET) - **Multi-client** : Support de plusieurs configs PDP par utilisateur (stored credentials ou zero-storage)  ### ✍️ Signature électronique PDF - **Standards** : PAdES-B-B, PAdES-B-T (horodatage RFC 3161), PAdES-B-LT (archivage long terme) - **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO) - **Validation** : Vérification intégrité cryptographique et certificats - **Génération de certificats** : Certificats X.509 auto-signés pour tests  ### 🔄 Traitement asynchrone - **Celery** : Génération, validation et signature asynchrones - **Polling** : Suivi d'état via `/taches/{id_tache}/statut` - **Pas de timeout** : Idéal pour gros fichiers ou validations lourdes  ## 🔒 Authentification  Toutes les requêtes nécessitent un **token JWT** dans le header Authorization : ``` Authorization: Bearer YOUR_JWT_TOKEN ```  ### Comment obtenir un token JWT ?  #### 🔑 Méthode 1 : API `/api/token/` (Recommandée)  **URL :** `https://www.factpulse.fr/api/token/`  Cette méthode est **recommandée** pour l'intégration dans vos applications et workflows CI/CD.  **Prérequis :** Avoir défini un mot de passe sur votre compte  **Pour les utilisateurs inscrits via email/password :** - Vous avez déjà un mot de passe, utilisez-le directement  **Pour les utilisateurs inscrits via OAuth (Google/GitHub) :** - Vous devez d'abord définir un mot de passe sur : https://www.factpulse.fr/accounts/password/set/ - Une fois le mot de passe créé, vous pourrez utiliser l'API  **Exemple de requête :** ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"votre_email@example.com\",     \"password\": \"votre_mot_de_passe\"   }' ```  **Réponse :** ```json {   \"access\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\",  // Token d'accès (validité: 30 min)   \"refresh\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\"  // Token de rafraîchissement (validité: 7 jours) } ```  **Avantages :** - ✅ Automatisation complète (CI/CD, scripts) - ✅ Gestion programmatique des tokens - ✅ Support du refresh token pour renouveler automatiquement l'accès - ✅ Intégration facile dans n'importe quel langage/outil  #### 🖥️ Méthode 2 : Génération via Dashboard (Alternative)  **URL :** https://www.factpulse.fr/dashboard/  Cette méthode convient pour des tests rapides ou une utilisation occasionnelle via l'interface graphique.  **Fonctionnement :** - Connectez-vous au dashboard - Utilisez les boutons \"Generate Test Token\" ou \"Generate Production Token\" - Fonctionne pour **tous** les utilisateurs (OAuth et email/password), sans nécessiter de mot de passe  **Types de tokens :** - **Token Test** : Validité 24h, quota 1000 appels/jour (gratuit) - **Token Production** : Validité 7 jours, quota selon votre forfait  **Avantages :** - ✅ Rapide pour tester l'API - ✅ Aucun mot de passe requis - ✅ Interface visuelle simple  **Inconvénients :** - ❌ Nécessite une action manuelle - ❌ Pas de refresh token - ❌ Moins adapté pour l'automatisation  ### 📚 Documentation complète  Pour plus d'informations sur l'authentification et l'utilisation de l'API : https://www.factpulse.fr/documentation-api/     
+     REST API for electronic invoicing in France: Factur-X, AFNOR PDP/PA, electronic signatures.  ## 🎯 Main Features  ### 📄 Factur-X Invoice Generation - **Formats**: XML only or PDF/A-3 with embedded XML - **Profiles**: MINIMUM, BASIC, EN16931, EXTENDED - **Standards**: EN 16931 (EU directive 2014/55), ISO 19005-3 (PDF/A-3), CII (UN/CEFACT) - **🆕 Simplified Format**: Generation from SIRET + auto-enrichment (Chorus Pro API + Business Search)  ### ✅ Validation and Compliance - **XML Validation**: Schematron (45 to 210+ rules depending on profile) - **PDF Validation**: PDF/A-3, Factur-X XMP metadata, electronic signatures - **VeraPDF**: Strict PDF/A validation (146+ ISO 19005-3 rules) - **Asynchronous Processing**: Celery support for heavy validations (VeraPDF)  ### 📡 AFNOR PDP/PA Integration (XP Z12-013) - **Flow Submission**: Send invoices to Partner Dematerialization Platforms - **Flow Search**: View submitted invoices - **Download**: Retrieve PDF/A-3 with XML - **Directory Service**: Company search (SIREN/SIRET) - **Multi-client**: Support for multiple PDP configs per user (stored credentials or zero-storage)  ### ✍️ PDF Electronic Signature - **Standards**: PAdES-B-B, PAdES-B-T (RFC 3161 timestamping), PAdES-B-LT (long-term archival) - **eIDAS Levels**: SES (self-signed), AdES (commercial CA), QES (QTSP) - **Validation**: Cryptographic integrity and certificate verification - **Certificate Generation**: Self-signed X.509 certificates for testing  ### 🔄 Asynchronous Processing - **Celery**: Asynchronous generation, validation and signing - **Polling**: Status tracking via `/tasks/{task_id}/status` - **No timeout**: Ideal for large files or heavy validations  ## 🔒 Authentication  All requests require a **JWT token** in the Authorization header: ``` Authorization: Bearer YOUR_JWT_TOKEN ```  ### How to obtain a JWT token?  #### 🔑 Method 1: `/api/token/` API (Recommended)  **URL:** `https://www.factpulse.fr/api/token/`  This method is **recommended** for integration in your applications and CI/CD workflows.  **Prerequisites:** Having set a password on your account  **For users registered via email/password:** - You already have a password, use it directly  **For users registered via OAuth (Google/GitHub):** - You must first set a password at: https://www.factpulse.fr/accounts/password/set/ - Once the password is created, you can use the API  **Request example:** ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"your_email@example.com\",     \"password\": \"your_password\"   }' ```  **Optional `client_uid` parameter:**  To select credentials for a specific client (PA/PDP, Chorus Pro, signing certificates), add `client_uid`:  ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"your_email@example.com\",     \"password\": \"your_password\",     \"client_uid\": \"550e8400-e29b-41d4-a716-446655440000\"   }' ```  The `client_uid` will be included in the JWT and allow the API to automatically use: - AFNOR/PDP credentials configured for this client - Chorus Pro credentials configured for this client - Electronic signature certificates configured for this client  **Response:** ```json {   \"access\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\",  // Access token (validity: 30 min)   \"refresh\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\"  // Refresh token (validity: 7 days) } ```  **Advantages:** - ✅ Full automation (CI/CD, scripts) - ✅ Programmatic token management - ✅ Refresh token support for automatic access renewal - ✅ Easy integration in any language/tool  #### 🖥️ Method 2: Dashboard Generation (Alternative)  **URL:** https://www.factpulse.fr/dashboard/  This method is suitable for quick tests or occasional use via the graphical interface.  **How it works:** - Log in to the dashboard - Use the \"Generate Test Token\" or \"Generate Production Token\" buttons - Works for **all** users (OAuth and email/password), without requiring a password  **Token types:** - **Test Token**: 24h validity, 1000 calls/day quota (free) - **Production Token**: 7 days validity, quota based on your plan  **Advantages:** - ✅ Quick for API testing - ✅ No password required - ✅ Simple visual interface  **Disadvantages:** - ❌ Requires manual action - ❌ No refresh token - ❌ Less suited for automation  ### 📚 Full Documentation  For more information on authentication and API usage: https://www.factpulse.fr/documentation-api/     
 
     The version of the OpenAPI document: 1.0.0
     Generated by OpenAPI Generator (https://openapi-generator.tech)
@@ -16,18 +16,17 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictBool, StrictBytes, StrictStr
-from typing import Any, Optional, Tuple, Union
+from pydantic import Field, StrictBytes, StrictStr
+from typing import Any, Dict, Optional, Tuple, Union
 from typing_extensions import Annotated
-from factpulse.models.generate_certificate_request import GenerateCertificateRequest
-from factpulse.models.generate_certificate_response import GenerateCertificateResponse
+from factpulse.models.convert_resume_request import ConvertResumeRequest
 
 from factpulse.api_client import ApiClient, RequestSerialized
 from factpulse.api_response import ApiResponse
 from factpulse.rest import RESTResponseType
 
 
-class SignatureLectroniqueApi:
+class DocumentConversionApi:
     """NOTE: This class is auto generated by OpenAPI Generator
     Ref: https://openapi-generator.tech
 
@@ -41,9 +40,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def generer_certificat_test_api_v1_traitement_generer_certificat_test_post(
+    def convert_document_api_v1_convert_post(
         self,
-        generate_certificate_request: GenerateCertificateRequest,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -56,13 +57,17 @@ class SignatureLectroniqueApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GenerateCertificateResponse:
-        """Générer un certificat X.509 auto-signé de test
+    ) -> ConvertSuccessResponse:
+        """Convertir un document en Factur-X
 
-        Génère un certificat X.509 auto-signé pour les tests de signature électronique PDF.      **⚠️ ATTENTION : Certificat de TEST uniquement !**      Ce certificat est :     - ✅ Adapté pour tests et développement     - ✅ Compatible signature PDF (PAdES)     - ✅ Conforme eIDAS niveau **SES** (Simple Electronic Signature)     - ❌ **JAMAIS utilisable en production**     - ❌ **Non reconnu** par les navigateurs et lecteurs PDF     - ❌ **Aucune valeur juridique**      ## Niveaux eIDAS      - **SES** (Simple) : Certificat auto-signé ← Généré par cet endpoint     - **AdES** (Advanced) : Certificat CA commerciale (Let's Encrypt, etc.)     - **QES** (Qualified) : Certificat qualifié PSCO (CertEurope, Universign, etc.)      ## Utilisation      Une fois généré, le certificat peut être :      1. **Enregistré dans Django** (recommandé) :        - Django Admin > Certificats de signature        - Upload `certificat_pem` et `cle_privee_pem`      2. **Utilisé directement** :        - Signer un PDF avec `/signer-pdf`        - Le certificat sera automatiquement utilisé      ## Exemple d'appel      ```bash     curl -X POST \"https://www.factpulse.fr/api/facturation/generer-certificat-test\" \\       -H \"Authorization: Bearer eyJ0eXAi...\" \\       -H \"Content-Type: application/json\" \\       -d '{         \"cn\": \"Test Client XYZ\",         \"organisation\": \"Client XYZ SARL\",         \"email\": \"contact@xyz.fr\",         \"duree_jours\": 365       }'     ```      ## Cas d'usage      - Tests de signature PDF en développement     - POC de signature électronique     - Formation et démos     - Tests d'intégration automatisés      ## Conformité technique      Certificat généré avec :     - Clé RSA 2048 ou 4096 bits     - Algorithme SHA-256     - Extensions Key Usage : `digitalSignature`, `contentCommitment` (non-repudiation)     - Extensions Extended Key Usage : `codeSigning`, `emailProtection`     - Validité : 1 jour à 10 ans (configurable)     - Format : PEM (certificat et clé)     - Optionnel : PKCS#12 (.p12)
+        Convertit un document (PDF, DOCX, XLSX, image) en Factur-X conforme.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Extraction OCR + Classification** : Mistral OCR extrait les données et classifie le document en un seul appel 3. **Enrichissement** : Les données sont enrichies via SIRENE (SIRET → raison sociale) 4. **Validation** : Les règles Schematron sont appliquées 5. **Génération** : Le Factur-X PDF/A-3 est généré  ## Réponses possibles  - **200** : Conversion réussie, fichiers disponibles - **202** : Données manquantes, complétion requise - **422** : Validation échouée, corrections nécessaires - **400** : Fichier invalide - **429** : Quota dépassé
 
-        :param generate_certificate_request: (required)
-        :type generate_certificate_request: GenerateCertificateRequest
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -85,8 +90,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._generer_certificat_test_api_v1_traitement_generer_certificat_test_post_serialize(
-            generate_certificate_request=generate_certificate_request,
+        _param = self._convert_document_api_v1_convert_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -94,10 +101,10 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GenerateCertificateResponse",
-            '400': None,
-            '500': None,
-            '422': "HTTPValidationError",
+            '200': "ConvertSuccessResponse",
+            '202': "ConvertPendingInputResponse",
+            '422': "ConvertValidationFailedResponse",
+            '400': "ConvertErrorResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -111,9 +118,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def generer_certificat_test_api_v1_traitement_generer_certificat_test_post_with_http_info(
+    def convert_document_api_v1_convert_post_with_http_info(
         self,
-        generate_certificate_request: GenerateCertificateRequest,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -126,13 +135,17 @@ class SignatureLectroniqueApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GenerateCertificateResponse]:
-        """Générer un certificat X.509 auto-signé de test
+    ) -> ApiResponse[ConvertSuccessResponse]:
+        """Convertir un document en Factur-X
 
-        Génère un certificat X.509 auto-signé pour les tests de signature électronique PDF.      **⚠️ ATTENTION : Certificat de TEST uniquement !**      Ce certificat est :     - ✅ Adapté pour tests et développement     - ✅ Compatible signature PDF (PAdES)     - ✅ Conforme eIDAS niveau **SES** (Simple Electronic Signature)     - ❌ **JAMAIS utilisable en production**     - ❌ **Non reconnu** par les navigateurs et lecteurs PDF     - ❌ **Aucune valeur juridique**      ## Niveaux eIDAS      - **SES** (Simple) : Certificat auto-signé ← Généré par cet endpoint     - **AdES** (Advanced) : Certificat CA commerciale (Let's Encrypt, etc.)     - **QES** (Qualified) : Certificat qualifié PSCO (CertEurope, Universign, etc.)      ## Utilisation      Une fois généré, le certificat peut être :      1. **Enregistré dans Django** (recommandé) :        - Django Admin > Certificats de signature        - Upload `certificat_pem` et `cle_privee_pem`      2. **Utilisé directement** :        - Signer un PDF avec `/signer-pdf`        - Le certificat sera automatiquement utilisé      ## Exemple d'appel      ```bash     curl -X POST \"https://www.factpulse.fr/api/facturation/generer-certificat-test\" \\       -H \"Authorization: Bearer eyJ0eXAi...\" \\       -H \"Content-Type: application/json\" \\       -d '{         \"cn\": \"Test Client XYZ\",         \"organisation\": \"Client XYZ SARL\",         \"email\": \"contact@xyz.fr\",         \"duree_jours\": 365       }'     ```      ## Cas d'usage      - Tests de signature PDF en développement     - POC de signature électronique     - Formation et démos     - Tests d'intégration automatisés      ## Conformité technique      Certificat généré avec :     - Clé RSA 2048 ou 4096 bits     - Algorithme SHA-256     - Extensions Key Usage : `digitalSignature`, `contentCommitment` (non-repudiation)     - Extensions Extended Key Usage : `codeSigning`, `emailProtection`     - Validité : 1 jour à 10 ans (configurable)     - Format : PEM (certificat et clé)     - Optionnel : PKCS#12 (.p12)
+        Convertit un document (PDF, DOCX, XLSX, image) en Factur-X conforme.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Extraction OCR + Classification** : Mistral OCR extrait les données et classifie le document en un seul appel 3. **Enrichissement** : Les données sont enrichies via SIRENE (SIRET → raison sociale) 4. **Validation** : Les règles Schematron sont appliquées 5. **Génération** : Le Factur-X PDF/A-3 est généré  ## Réponses possibles  - **200** : Conversion réussie, fichiers disponibles - **202** : Données manquantes, complétion requise - **422** : Validation échouée, corrections nécessaires - **400** : Fichier invalide - **429** : Quota dépassé
 
-        :param generate_certificate_request: (required)
-        :type generate_certificate_request: GenerateCertificateRequest
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -155,8 +168,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._generer_certificat_test_api_v1_traitement_generer_certificat_test_post_serialize(
-            generate_certificate_request=generate_certificate_request,
+        _param = self._convert_document_api_v1_convert_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -164,10 +179,10 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GenerateCertificateResponse",
-            '400': None,
-            '500': None,
-            '422': "HTTPValidationError",
+            '200': "ConvertSuccessResponse",
+            '202': "ConvertPendingInputResponse",
+            '422': "ConvertValidationFailedResponse",
+            '400': "ConvertErrorResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -181,9 +196,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def generer_certificat_test_api_v1_traitement_generer_certificat_test_post_without_preload_content(
+    def convert_document_api_v1_convert_post_without_preload_content(
         self,
-        generate_certificate_request: GenerateCertificateRequest,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -197,12 +214,16 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Générer un certificat X.509 auto-signé de test
+        """Convertir un document en Factur-X
 
-        Génère un certificat X.509 auto-signé pour les tests de signature électronique PDF.      **⚠️ ATTENTION : Certificat de TEST uniquement !**      Ce certificat est :     - ✅ Adapté pour tests et développement     - ✅ Compatible signature PDF (PAdES)     - ✅ Conforme eIDAS niveau **SES** (Simple Electronic Signature)     - ❌ **JAMAIS utilisable en production**     - ❌ **Non reconnu** par les navigateurs et lecteurs PDF     - ❌ **Aucune valeur juridique**      ## Niveaux eIDAS      - **SES** (Simple) : Certificat auto-signé ← Généré par cet endpoint     - **AdES** (Advanced) : Certificat CA commerciale (Let's Encrypt, etc.)     - **QES** (Qualified) : Certificat qualifié PSCO (CertEurope, Universign, etc.)      ## Utilisation      Une fois généré, le certificat peut être :      1. **Enregistré dans Django** (recommandé) :        - Django Admin > Certificats de signature        - Upload `certificat_pem` et `cle_privee_pem`      2. **Utilisé directement** :        - Signer un PDF avec `/signer-pdf`        - Le certificat sera automatiquement utilisé      ## Exemple d'appel      ```bash     curl -X POST \"https://www.factpulse.fr/api/facturation/generer-certificat-test\" \\       -H \"Authorization: Bearer eyJ0eXAi...\" \\       -H \"Content-Type: application/json\" \\       -d '{         \"cn\": \"Test Client XYZ\",         \"organisation\": \"Client XYZ SARL\",         \"email\": \"contact@xyz.fr\",         \"duree_jours\": 365       }'     ```      ## Cas d'usage      - Tests de signature PDF en développement     - POC de signature électronique     - Formation et démos     - Tests d'intégration automatisés      ## Conformité technique      Certificat généré avec :     - Clé RSA 2048 ou 4096 bits     - Algorithme SHA-256     - Extensions Key Usage : `digitalSignature`, `contentCommitment` (non-repudiation)     - Extensions Extended Key Usage : `codeSigning`, `emailProtection`     - Validité : 1 jour à 10 ans (configurable)     - Format : PEM (certificat et clé)     - Optionnel : PKCS#12 (.p12)
+        Convertit un document (PDF, DOCX, XLSX, image) en Factur-X conforme.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Extraction OCR + Classification** : Mistral OCR extrait les données et classifie le document en un seul appel 3. **Enrichissement** : Les données sont enrichies via SIRENE (SIRET → raison sociale) 4. **Validation** : Les règles Schematron sont appliquées 5. **Génération** : Le Factur-X PDF/A-3 est généré  ## Réponses possibles  - **200** : Conversion réussie, fichiers disponibles - **202** : Données manquantes, complétion requise - **422** : Validation échouée, corrections nécessaires - **400** : Fichier invalide - **429** : Quota dépassé
 
-        :param generate_certificate_request: (required)
-        :type generate_certificate_request: GenerateCertificateRequest
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -225,8 +246,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._generer_certificat_test_api_v1_traitement_generer_certificat_test_post_serialize(
-            generate_certificate_request=generate_certificate_request,
+        _param = self._convert_document_api_v1_convert_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -234,10 +257,10 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GenerateCertificateResponse",
-            '400': None,
-            '500': None,
-            '422': "HTTPValidationError",
+            '200': "ConvertSuccessResponse",
+            '202': "ConvertPendingInputResponse",
+            '422': "ConvertValidationFailedResponse",
+            '400': "ConvertErrorResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -246,9 +269,11 @@ class SignatureLectroniqueApi:
         return response_data.response
 
 
-    def _generer_certificat_test_api_v1_traitement_generer_certificat_test_post_serialize(
+    def _convert_document_api_v1_convert_post_serialize(
         self,
-        generate_certificate_request,
+        file,
+        output,
+        callback_url,
         _request_auth,
         _content_type,
         _headers,
@@ -273,9 +298,13 @@ class SignatureLectroniqueApi:
         # process the query parameters
         # process the header parameters
         # process the form parameters
+        if file is not None:
+            _files['file'] = file
+        if output is not None:
+            _form_params.append(('output', output))
+        if callback_url is not None:
+            _form_params.append(('callback_url', callback_url))
         # process the body parameter
-        if generate_certificate_request is not None:
-            _body_params = generate_certificate_request
 
 
         # set the HTTP header `Accept`
@@ -293,7 +322,7 @@ class SignatureLectroniqueApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json'
+                        'multipart/form-data'
                     ]
                 )
             )
@@ -307,7 +336,7 @@ class SignatureLectroniqueApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v1/traitement/generer-certificat-test',
+            resource_path='/api/v1/convert',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -324,15 +353,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_api_v1_traitement_signer_pdf_post(
+    def convert_document_async_api_v1_convert_async_post(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (sera traité puis retourné signé en base64)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -346,24 +371,16 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> object:
-        """Signer un PDF avec le certificat du client (PAdES-B-LT)
-
-        Signe un PDF uploadé avec le certificat électronique configuré pour le client (via client_uid du JWT).      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO - hors scope).      **⚠️ Disclaimer légal** : Les signatures générées sont des cachets électroniques au sens     du règlement eIDAS. Le niveau de validité juridique dépend du certificat utilisé (SES/AdES/QES).     FactPulse ne fournit pas de certificats qualifiés QES - vous devez obtenir un certificat auprès     d'un PSCO (Prestataire de Services de Confiance qualifié) pour une validité juridique maximale.
-
-        :param fichier_pdf: Fichier PDF à signer (sera traité puis retourné signé en base64) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Convertir un document en Factur-X (mode asynchrone)
+
+        Lance une conversion asynchrone via Celery.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Task Celery** : La tâche est mise en file d'attente 3. **Callback** : Notification par webhook à la fin  ## Réponses possibles  - **202** : Tâche acceptée, en cours de traitement - **400** : Fichier invalide
+
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -386,14 +403,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_api_v1_traitement_signer_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._convert_document_async_api_v1_convert_async_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -402,10 +415,8 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
+            '202': None,
             '400': None,
-            '404': None,
-            '401': None,
-            '503': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -420,15 +431,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_api_v1_traitement_signer_pdf_post_with_http_info(
+    def convert_document_async_api_v1_convert_async_post_with_http_info(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (sera traité puis retourné signé en base64)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -442,24 +449,16 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[object]:
-        """Signer un PDF avec le certificat du client (PAdES-B-LT)
-
-        Signe un PDF uploadé avec le certificat électronique configuré pour le client (via client_uid du JWT).      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO - hors scope).      **⚠️ Disclaimer légal** : Les signatures générées sont des cachets électroniques au sens     du règlement eIDAS. Le niveau de validité juridique dépend du certificat utilisé (SES/AdES/QES).     FactPulse ne fournit pas de certificats qualifiés QES - vous devez obtenir un certificat auprès     d'un PSCO (Prestataire de Services de Confiance qualifié) pour une validité juridique maximale.
-
-        :param fichier_pdf: Fichier PDF à signer (sera traité puis retourné signé en base64) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Convertir un document en Factur-X (mode asynchrone)
+
+        Lance une conversion asynchrone via Celery.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Task Celery** : La tâche est mise en file d'attente 3. **Callback** : Notification par webhook à la fin  ## Réponses possibles  - **202** : Tâche acceptée, en cours de traitement - **400** : Fichier invalide
+
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -482,14 +481,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_api_v1_traitement_signer_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._convert_document_async_api_v1_convert_async_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -498,10 +493,8 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
+            '202': None,
             '400': None,
-            '404': None,
-            '401': None,
-            '503': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -516,15 +509,11 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_api_v1_traitement_signer_pdf_post_without_preload_content(
+    def convert_document_async_api_v1_convert_async_post_without_preload_content(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (sera traité puis retourné signé en base64)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Document à convertir (PDF, DOCX, XLSX, JPG, PNG)")],
+        output: Annotated[Optional[StrictStr], Field(description="Format de sortie: pdf, xml, both")] = None,
+        callback_url: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -538,24 +527,16 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Signer un PDF avec le certificat du client (PAdES-B-LT)
-
-        Signe un PDF uploadé avec le certificat électronique configuré pour le client (via client_uid du JWT).      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO - hors scope).      **⚠️ Disclaimer légal** : Les signatures générées sont des cachets électroniques au sens     du règlement eIDAS. Le niveau de validité juridique dépend du certificat utilisé (SES/AdES/QES).     FactPulse ne fournit pas de certificats qualifiés QES - vous devez obtenir un certificat auprès     d'un PSCO (Prestataire de Services de Confiance qualifié) pour une validité juridique maximale.
-
-        :param fichier_pdf: Fichier PDF à signer (sera traité puis retourné signé en base64) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Convertir un document en Factur-X (mode asynchrone)
+
+        Lance une conversion asynchrone via Celery.  ## Workflow  1. **Upload** : Le document est envoyé en multipart/form-data 2. **Task Celery** : La tâche est mise en file d'attente 3. **Callback** : Notification par webhook à la fin  ## Réponses possibles  - **202** : Tâche acceptée, en cours de traitement - **400** : Fichier invalide
+
+        :param file: Document à convertir (PDF, DOCX, XLSX, JPG, PNG) (required)
+        :type file: bytearray
+        :param output: Format de sortie: pdf, xml, both
+        :type output: str
+        :param callback_url:
+        :type callback_url: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -578,14 +559,10 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_api_v1_traitement_signer_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._convert_document_async_api_v1_convert_async_post_serialize(
+            file=file,
+            output=output,
+            callback_url=callback_url,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -594,10 +571,8 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
+            '202': None,
             '400': None,
-            '404': None,
-            '401': None,
-            '503': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -607,15 +582,11 @@ class SignatureLectroniqueApi:
         return response_data.response
 
 
-    def _signer_pdf_api_v1_traitement_signer_pdf_post_serialize(
+    def _convert_document_async_api_v1_convert_async_post_serialize(
         self,
-        fichier_pdf,
-        raison,
-        localisation,
-        contact,
-        field_name,
-        use_pades_lt,
-        use_timestamp,
+        file,
+        output,
+        callback_url,
         _request_auth,
         _content_type,
         _headers,
@@ -640,20 +611,12 @@ class SignatureLectroniqueApi:
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if fichier_pdf is not None:
-            _files['fichier_pdf'] = fichier_pdf
-        if raison is not None:
-            _form_params.append(('raison', raison))
-        if localisation is not None:
-            _form_params.append(('localisation', localisation))
-        if contact is not None:
-            _form_params.append(('contact', contact))
-        if field_name is not None:
-            _form_params.append(('field_name', field_name))
-        if use_pades_lt is not None:
-            _form_params.append(('use_pades_lt', use_pades_lt))
-        if use_timestamp is not None:
-            _form_params.append(('use_timestamp', use_timestamp))
+        if file is not None:
+            _files['file'] = file
+        if output is not None:
+            _form_params.append(('output', output))
+        if callback_url is not None:
+            _form_params.append(('callback_url', callback_url))
         # process the body parameter
 
 
@@ -686,7 +649,7 @@ class SignatureLectroniqueApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v1/traitement/signer-pdf',
+            resource_path='/api/v1/convert/async',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -703,15 +666,10 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_async_api_v1_traitement_signer_pdf_async_post(
+    def download_file_api_v1_convert_conversion_id_download_filename_get(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (traité de manière asynchrone)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        conversion_id: StrictStr,
+        filename: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -725,24 +683,14 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> object:
-        """Signer un PDF de manière asynchrone (Celery)
-
-        Signe un PDF uploadé de manière asynchrone via une tâche Celery.      **Différence avec /signer-pdf** :     - `/signer-pdf` : Signature synchrone (blocage jusqu'à la fin)     - `/signer-pdf-async` : Signature asynchrone (retourne immédiatement un task_id)      **Avantages de l'async** :     - Pas de timeout pour les gros fichiers     - Pas de blocage du worker FastAPI     - Possibilité de suivre la progression via le task_id     - Idéal pour les traitements par lot      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **⚠️ Disclaimer légal** : Identique à /signer-pdf (voir documentation de cet endpoint).
-
-        :param fichier_pdf: Fichier PDF à signer (traité de manière asynchrone) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Télécharger un fichier généré
+
+        Télécharge le fichier Factur-X PDF ou XML généré.  ## Fichiers disponibles  - `facturx.pdf` : PDF/A-3 avec XML embarqué - `facturx.xml` : XML CII seul (Cross Industry Invoice)  Les fichiers sont disponibles pendant 24 heures après génération.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param filename: (required)
+        :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -765,14 +713,9 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_async_api_v1_traitement_signer_pdf_async_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._download_file_api_v1_convert_conversion_id_download_filename_get_serialize(
+            conversion_id=conversion_id,
+            filename=filename,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -781,9 +724,7 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
-            '202': None,
-            '400': None,
-            '401': None,
+            '404': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -798,15 +739,10 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_async_api_v1_traitement_signer_pdf_async_post_with_http_info(
+    def download_file_api_v1_convert_conversion_id_download_filename_get_with_http_info(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (traité de manière asynchrone)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        conversion_id: StrictStr,
+        filename: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -820,24 +756,14 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[object]:
-        """Signer un PDF de manière asynchrone (Celery)
-
-        Signe un PDF uploadé de manière asynchrone via une tâche Celery.      **Différence avec /signer-pdf** :     - `/signer-pdf` : Signature synchrone (blocage jusqu'à la fin)     - `/signer-pdf-async` : Signature asynchrone (retourne immédiatement un task_id)      **Avantages de l'async** :     - Pas de timeout pour les gros fichiers     - Pas de blocage du worker FastAPI     - Possibilité de suivre la progression via le task_id     - Idéal pour les traitements par lot      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **⚠️ Disclaimer légal** : Identique à /signer-pdf (voir documentation de cet endpoint).
-
-        :param fichier_pdf: Fichier PDF à signer (traité de manière asynchrone) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Télécharger un fichier généré
+
+        Télécharge le fichier Factur-X PDF ou XML généré.  ## Fichiers disponibles  - `facturx.pdf` : PDF/A-3 avec XML embarqué - `facturx.xml` : XML CII seul (Cross Industry Invoice)  Les fichiers sont disponibles pendant 24 heures après génération.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param filename: (required)
+        :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -860,14 +786,9 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_async_api_v1_traitement_signer_pdf_async_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._download_file_api_v1_convert_conversion_id_download_filename_get_serialize(
+            conversion_id=conversion_id,
+            filename=filename,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -876,9 +797,7 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
-            '202': None,
-            '400': None,
-            '401': None,
+            '404': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -893,15 +812,10 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def signer_pdf_async_api_v1_traitement_signer_pdf_async_post_without_preload_content(
+    def download_file_api_v1_convert_conversion_id_download_filename_get_without_preload_content(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à signer (traité de manière asynchrone)")],
-        raison: Optional[StrictStr] = None,
-        localisation: Optional[StrictStr] = None,
-        contact: Optional[StrictStr] = None,
-        field_name: Annotated[Optional[StrictStr], Field(description="Nom du champ de signature PDF")] = None,
-        use_pades_lt: Annotated[Optional[StrictBool], Field(description="Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.")] = None,
-        use_timestamp: Annotated[Optional[StrictBool], Field(description="Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)")] = None,
+        conversion_id: StrictStr,
+        filename: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -915,24 +829,14 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Signer un PDF de manière asynchrone (Celery)
-
-        Signe un PDF uploadé de manière asynchrone via une tâche Celery.      **Différence avec /signer-pdf** :     - `/signer-pdf` : Signature synchrone (blocage jusqu'à la fin)     - `/signer-pdf-async` : Signature asynchrone (retourne immédiatement un task_id)      **Avantages de l'async** :     - Pas de timeout pour les gros fichiers     - Pas de blocage du worker FastAPI     - Possibilité de suivre la progression via le task_id     - Idéal pour les traitements par lot      **Standards supportés** : PAdES-B-B, PAdES-B-T (horodatage), PAdES-B-LT (archivage long terme).      **⚠️ Disclaimer légal** : Identique à /signer-pdf (voir documentation de cet endpoint).
-
-        :param fichier_pdf: Fichier PDF à signer (traité de manière asynchrone) (required)
-        :type fichier_pdf: bytearray
-        :param raison:
-        :type raison: str
-        :param localisation:
-        :type localisation: str
-        :param contact:
-        :type contact: str
-        :param field_name: Nom du champ de signature PDF
-        :type field_name: str
-        :param use_pades_lt: Activer PAdES-B-LT (archivage long terme avec données de validation embarquées). NÉCESSITE un certificat avec accès OCSP/CRL.
-        :type use_pades_lt: bool
-        :param use_timestamp: Activer l'horodatage RFC 3161 avec FreeTSA (PAdES-B-T)
-        :type use_timestamp: bool
+        """Télécharger un fichier généré
+
+        Télécharge le fichier Factur-X PDF ou XML généré.  ## Fichiers disponibles  - `facturx.pdf` : PDF/A-3 avec XML embarqué - `facturx.xml` : XML CII seul (Cross Industry Invoice)  Les fichiers sont disponibles pendant 24 heures après génération.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param filename: (required)
+        :type filename: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -955,14 +859,9 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._signer_pdf_async_api_v1_traitement_signer_pdf_async_post_serialize(
-            fichier_pdf=fichier_pdf,
-            raison=raison,
-            localisation=localisation,
-            contact=contact,
-            field_name=field_name,
-            use_pades_lt=use_pades_lt,
-            use_timestamp=use_timestamp,
+        _param = self._download_file_api_v1_convert_conversion_id_download_filename_get_serialize(
+            conversion_id=conversion_id,
+            filename=filename,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -971,9 +870,7 @@ class SignatureLectroniqueApi:
 
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "object",
-            '202': None,
-            '400': None,
-            '401': None,
+            '404': None,
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -983,15 +880,10 @@ class SignatureLectroniqueApi:
         return response_data.response
 
 
-    def _signer_pdf_async_api_v1_traitement_signer_pdf_async_post_serialize(
+    def _download_file_api_v1_convert_conversion_id_download_filename_get_serialize(
         self,
-        fichier_pdf,
-        raison,
-        localisation,
-        contact,
-        field_name,
-        use_pades_lt,
-        use_timestamp,
+        conversion_id,
+        filename,
         _request_auth,
         _content_type,
         _headers,
@@ -1013,23 +905,13 @@ class SignatureLectroniqueApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if conversion_id is not None:
+            _path_params['conversion_id'] = conversion_id
+        if filename is not None:
+            _path_params['filename'] = filename
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if fichier_pdf is not None:
-            _files['fichier_pdf'] = fichier_pdf
-        if raison is not None:
-            _form_params.append(('raison', raison))
-        if localisation is not None:
-            _form_params.append(('localisation', localisation))
-        if contact is not None:
-            _form_params.append(('contact', contact))
-        if field_name is not None:
-            _form_params.append(('field_name', field_name))
-        if use_pades_lt is not None:
-            _form_params.append(('use_pades_lt', use_pades_lt))
-        if use_timestamp is not None:
-            _form_params.append(('use_timestamp', use_timestamp))
         # process the body parameter
 
 
@@ -1041,19 +923,6 @@ class SignatureLectroniqueApi:
                 ]
             )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -1061,8 +930,8 @@ class SignatureLectroniqueApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/api/v1/traitement/signer-pdf-async',
+            method='GET',
+            resource_path='/api/v1/convert/{conversion_id}/download/{filename}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1079,9 +948,9 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post(
+    def get_conversion_status_api_v1_convert_conversion_id_status_get(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à valider (sera analysé pour détecter et valider les signatures)")],
+        conversion_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1094,13 +963,13 @@ class SignatureLectroniqueApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> object:
-        """Valider les signatures électroniques d'un PDF
+    ) -> Dict[str, object]:
+        """Vérifier le statut d'une conversion
 
-        Valide les signatures électroniques présentes dans un PDF uploadé.      **Vérifications effectuées** :     - Présence de signatures     - Intégrité du document (non modifié depuis signature)     - Validité des certificats     - Chaîne de confiance (si disponible)     - Présence d'horodatage (PAdES-B-T)     - Données de validation (PAdES-B-LT)      **Standards supportés** : PAdES-B-B, PAdES-B-T, PAdES-B-LT, ISO 32000-2.      **⚠️ Note** : Cette validation est technique (intégrité cryptographique). La validité juridique     dépend du niveau eIDAS du certificat (SES/AdES/QES) et du contexte d'utilisation.
+        Retourne le statut actuel d'une conversion asynchrone.
 
-        :param fichier_pdf: Fichier PDF à valider (sera analysé pour détecter et valider les signatures) (required)
-        :type fichier_pdf: bytearray
+        :param conversion_id: (required)
+        :type conversion_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1123,8 +992,8 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
+        _param = self._get_conversion_status_api_v1_convert_conversion_id_status_get_serialize(
+            conversion_id=conversion_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1132,8 +1001,7 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-            '400': None,
+            '200': "Dict[str, object]",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -1148,9 +1016,9 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_with_http_info(
+    def get_conversion_status_api_v1_convert_conversion_id_status_get_with_http_info(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à valider (sera analysé pour détecter et valider les signatures)")],
+        conversion_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1163,13 +1031,13 @@ class SignatureLectroniqueApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[object]:
-        """Valider les signatures électroniques d'un PDF
+    ) -> ApiResponse[Dict[str, object]]:
+        """Vérifier le statut d'une conversion
 
-        Valide les signatures électroniques présentes dans un PDF uploadé.      **Vérifications effectuées** :     - Présence de signatures     - Intégrité du document (non modifié depuis signature)     - Validité des certificats     - Chaîne de confiance (si disponible)     - Présence d'horodatage (PAdES-B-T)     - Données de validation (PAdES-B-LT)      **Standards supportés** : PAdES-B-B, PAdES-B-T, PAdES-B-LT, ISO 32000-2.      **⚠️ Note** : Cette validation est technique (intégrité cryptographique). La validité juridique     dépend du niveau eIDAS du certificat (SES/AdES/QES) et du contexte d'utilisation.
+        Retourne le statut actuel d'une conversion asynchrone.
 
-        :param fichier_pdf: Fichier PDF à valider (sera analysé pour détecter et valider les signatures) (required)
-        :type fichier_pdf: bytearray
+        :param conversion_id: (required)
+        :type conversion_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1192,8 +1060,8 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
+        _param = self._get_conversion_status_api_v1_convert_conversion_id_status_get_serialize(
+            conversion_id=conversion_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1201,8 +1069,7 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-            '400': None,
+            '200': "Dict[str, object]",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -1217,9 +1084,9 @@ class SignatureLectroniqueApi:
 
 
     @validate_call
-    def valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_without_preload_content(
+    def get_conversion_status_api_v1_convert_conversion_id_status_get_without_preload_content(
         self,
-        fichier_pdf: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="Fichier PDF à valider (sera analysé pour détecter et valider les signatures)")],
+        conversion_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1233,12 +1100,12 @@ class SignatureLectroniqueApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Valider les signatures électroniques d'un PDF
+        """Vérifier le statut d'une conversion
 
-        Valide les signatures électroniques présentes dans un PDF uploadé.      **Vérifications effectuées** :     - Présence de signatures     - Intégrité du document (non modifié depuis signature)     - Validité des certificats     - Chaîne de confiance (si disponible)     - Présence d'horodatage (PAdES-B-T)     - Données de validation (PAdES-B-LT)      **Standards supportés** : PAdES-B-B, PAdES-B-T, PAdES-B-LT, ISO 32000-2.      **⚠️ Note** : Cette validation est technique (intégrité cryptographique). La validité juridique     dépend du niveau eIDAS du certificat (SES/AdES/QES) et du contexte d'utilisation.
+        Retourne le statut actuel d'une conversion asynchrone.
 
-        :param fichier_pdf: Fichier PDF à valider (sera analysé pour détecter et valider les signatures) (required)
-        :type fichier_pdf: bytearray
+        :param conversion_id: (required)
+        :type conversion_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1261,8 +1128,8 @@ class SignatureLectroniqueApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_serialize(
-            fichier_pdf=fichier_pdf,
+        _param = self._get_conversion_status_api_v1_convert_conversion_id_status_get_serialize(
+            conversion_id=conversion_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1270,8 +1137,7 @@ class SignatureLectroniqueApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-            '400': None,
+            '200': "Dict[str, object]",
             '422': "HTTPValidationError",
         }
         response_data = self.api_client.call_api(
@@ -1281,9 +1147,289 @@ class SignatureLectroniqueApi:
         return response_data.response
 
 
-    def _valider_signature_pdf_endpoint_api_v1_traitement_valider_signature_pdf_post_serialize(
+    def _get_conversion_status_api_v1_convert_conversion_id_status_get_serialize(
+        self,
+        conversion_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if conversion_id is not None:
+            _path_params['conversion_id'] = conversion_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'HTTPBearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/api/v1/convert/{conversion_id}/status',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def resume_conversion_api_v1_convert_conversion_id_resume_post(
+        self,
+        conversion_id: StrictStr,
+        convert_resume_request: ConvertResumeRequest,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ConvertSuccessResponse:
+        """Reprendre une conversion avec corrections
+
+        Reprend une conversion après complétion des données manquantes ou correction des erreurs.  L'extraction OCR est conservée, les données sont mises à jour avec les corrections, puis une nouvelle validation Schematron est effectuée.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param convert_resume_request: (required)
+        :type convert_resume_request: ConvertResumeRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._resume_conversion_api_v1_convert_conversion_id_resume_post_serialize(
+            conversion_id=conversion_id,
+            convert_resume_request=convert_resume_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConvertSuccessResponse",
+            '404': None,
+            '422': "ConvertValidationFailedResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def resume_conversion_api_v1_convert_conversion_id_resume_post_with_http_info(
+        self,
+        conversion_id: StrictStr,
+        convert_resume_request: ConvertResumeRequest,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[ConvertSuccessResponse]:
+        """Reprendre une conversion avec corrections
+
+        Reprend une conversion après complétion des données manquantes ou correction des erreurs.  L'extraction OCR est conservée, les données sont mises à jour avec les corrections, puis une nouvelle validation Schematron est effectuée.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param convert_resume_request: (required)
+        :type convert_resume_request: ConvertResumeRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._resume_conversion_api_v1_convert_conversion_id_resume_post_serialize(
+            conversion_id=conversion_id,
+            convert_resume_request=convert_resume_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConvertSuccessResponse",
+            '404': None,
+            '422': "ConvertValidationFailedResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def resume_conversion_api_v1_convert_conversion_id_resume_post_without_preload_content(
+        self,
+        conversion_id: StrictStr,
+        convert_resume_request: ConvertResumeRequest,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Reprendre une conversion avec corrections
+
+        Reprend une conversion après complétion des données manquantes ou correction des erreurs.  L'extraction OCR est conservée, les données sont mises à jour avec les corrections, puis une nouvelle validation Schematron est effectuée.
+
+        :param conversion_id: (required)
+        :type conversion_id: str
+        :param convert_resume_request: (required)
+        :type convert_resume_request: ConvertResumeRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._resume_conversion_api_v1_convert_conversion_id_resume_post_serialize(
+            conversion_id=conversion_id,
+            convert_resume_request=convert_resume_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConvertSuccessResponse",
+            '404': None,
+            '422': "ConvertValidationFailedResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _resume_conversion_api_v1_convert_conversion_id_resume_post_serialize(
         self,
-        fichier_pdf,
+        conversion_id,
+        convert_resume_request,
         _request_auth,
         _content_type,
         _headers,
@@ -1305,12 +1451,14 @@ class SignatureLectroniqueApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if conversion_id is not None:
+            _path_params['conversion_id'] = conversion_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if fichier_pdf is not None:
-            _files['fichier_pdf'] = fichier_pdf
         # process the body parameter
+        if convert_resume_request is not None:
+            _body_params = convert_resume_request
 
 
         # set the HTTP header `Accept`
@@ -1328,7 +1476,7 @@ class SignatureLectroniqueApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'multipart/form-data'
+                        'application/json'
                     ]
                 )
             )
@@ -1342,7 +1490,7 @@ class SignatureLectroniqueApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v1/traitement/valider-signature-pdf',
+            resource_path='/api/v1/convert/{conversion_id}/resume',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,