@communecter/cocolight-api-client 1.0.132 → 1.0.134

package/src/api/BaseEntity.ts

@@ -79,6 +79,7 @@ type BadgeInput = { id: string } | Record<string, any>;
 type NewsInput = { id: string } | Record<string, any>;
 type ActionInput = { id: string } | Record<string, any>;
 type FormInput = { id: string } | Record<string, any>;
+type AnswerInput = { id: string } | Record<string, any>;
 
 /**
  * On force le type de l'import comme une fabrique qui renvoie un objet
@@ -163,7 +164,7 @@ interface EntityTypeMap {
 }
 
 // Types pour les streams et uploads
-type ReadableWithMeta = import("stream").Readable & { path?: string, mimeType?: string };
+type ReadableWithMeta = import("stream").Readable & { path?: string, mimeType?: string, size?: number };
 type UploadInput = File | Blob | Buffer | import("stream").Readable;
 type ValidatedUpload = File | Buffer | ReadableWithMeta;
 
@@ -1156,6 +1157,74 @@ export class BaseEntity<TServerData = any> {
     return file;
   }
 
+  /**
+   * Prépare un fichier pour un upload multipart **sans restriction MIME**.
+   *
+   * Diffère de `_validateImage` / `_validateFile` (liste MIME blanche stricte) :
+   * accepte tout MIME et garantit la conversion `Buffer → annotated stream` en
+   * Node (le multipart encoder du package `form-data` ignore les Buffer bruts ;
+   * il a besoin de `path` + `mimeType` sur un Readable).
+   *
+   * Pensé pour les endpoints d'upload large-spectre (ex: coform où l'utilisateur
+   * peut uploader PNG, GIF, WebP, PDF, DOCX, XLSX, etc. — c'est le backend qui
+   * filtre selon la config du Form, pas le client).
+   *
+   * Compatible browser + Node :
+   *  - Browser `File`    → pass-through
+   *  - Browser `Blob`    → wrap en `File` (génère nom + extension via MIME)
+   *  - Node `Buffer`     → détecte MIME via `file-type`, convertit en `Readable`
+   *                        annoté (`path`, `mimeType`)
+   *  - Node `Readable`   → pass-through si annoté, sinon utilise `fallbackName`
+   *
+   * @param input - Fichier à uploader (Buffer/File/Blob/Readable)
+   * @param fallbackName - Nom à utiliser si l'input n'en porte pas. Défaut `upload-<ts>`.
+   * @returns `{ qqfile, qqfilename, qqtotalfilesize }` prêt pour multipart.
+   * @throws {ApiError} si le type de l'input n'est pas reconnu.
+   *
+   * @protected
+   */
+  protected async _prepareUploadFile(
+    input: UploadInput,
+    fallbackName: string = `upload-${Date.now()}`,
+  ): Promise<{ qqfile: ValidatedUpload; qqfilename: string; qqtotalfilesize: number }> {
+    const isNode = typeof window === "undefined" && typeof process !== "undefined";
+
+    // Browser : File natif
+    if (typeof File !== "undefined" && input instanceof File) {
+      return { qqfile: input, qqfilename: input.name, qqtotalfilesize: input.size };
+    }
+
+    // Browser : Blob → wrap en File
+    if (typeof Blob !== "undefined" && input instanceof Blob) {
+      const ext = input.type.split("/")[1] || "bin";
+      const name = `${fallbackName}.${ext}`;
+      const file = new File([input], name, { type: input.type });
+      return { qqfile: file, qqfilename: name, qqtotalfilesize: file.size };
+    }
+
+    // Node : Buffer → annotated stream (file-type pour MIME)
+    if (isNode && Buffer.isBuffer(input)) {
+      const ft = await fromBuffer(input);
+      const mime = ft?.mime ?? "application/octet-stream";
+      const ext = ft?.ext ?? "bin";
+      const name = /\.[a-z0-9]+$/i.test(fallbackName) ? fallbackName : `${fallbackName}.${ext}`;
+      const stream = await this._createReadStreamFromBuffer(input, name, mime);
+      return { qqfile: stream, qqfilename: name, qqtotalfilesize: input.length };
+    }
+
+    // Node : Readable déjà annoté (ex: fs.createReadStream)
+    if (isNode && input && typeof (input as { pipe?: unknown }).pipe === "function") {
+      const stream = input as ReadableWithMeta;
+      const name = (typeof stream.path === "string" && stream.path) || fallbackName;
+      // `.size` peut être annoté manuellement par le caller (cf. `fs.statSync(...).size`).
+      // Si absent → 0, à compléter via `opts.qqtotalfilesize` côté méthode appelante.
+      const size = typeof stream.size === "number" ? stream.size : 0;
+      return { qqfile: stream, qqfilename: name, qqtotalfilesize: size };
+    }
+
+    throw new ApiError("Type de fichier non reconnu pour l'upload.", 400);
+  }
+
   /**
    * Valide les entrées d'upload de fichiers.
    *
@@ -1268,14 +1337,17 @@ export class BaseEntity<TServerData = any> {
   }
 
   /**
-   * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream
+   * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream.
+   *
+   * Note : passé `protected` car réutilisé par `_prepareUploadFile()` (Answer).
+   *
    * @param buffer - Le buffer contenant les données binaires
    * @param [filename="file.bin"] - Nom de fichier (utilisé dans FormData)
    * @param [mimeType="application/octet-stream"] - Type MIME (utilisé dans FormData)
    * @returns - Readable doté de `path` et `mimeType`
-   * @private
+   * @protected
    */
-  private async _createReadStreamFromBuffer(buffer: Buffer, filename = "file.bin", mimeType = "application/octet-stream"): Promise<ReadableWithMeta> {
+  protected async _createReadStreamFromBuffer(buffer: Buffer, filename = "file.bin", mimeType = "application/octet-stream"): Promise<ReadableWithMeta> {
     const stream = await this._bufferToReadable(buffer);
     (stream as ReadableWithMeta).path = filename;
     (stream as ReadableWithMeta).mimeType = mimeType;
@@ -3325,6 +3397,24 @@ export class BaseEntity<TServerData = any> {
     return entity as Form;
   }
 
+  /**
+   * Crée une instance d'Answer rattachée à l'entité courante.
+   *
+   * Méthode autorisée uniquement sur `Form` (la seule entité qui porte un
+   * `id` de formulaire pré-rempli pour les drafts). Les autres entités la
+   * bloquent via cet override par défaut qui throw.
+   *
+   * Pour fetch une Answer existante sans contexte Form, passer par
+   * `EntityRegistry.createEntityFromData` ou un endpoint adhoc.
+   *
+   * @param _answerData - `{ id: string }` (fetch) ou objet partiel (draft).
+   * @returns Une Answer.
+   * @throws {ApiError} 501 sur les entités non supportées.
+   */
+  async answer(_answerData: AnswerInput = {}): Promise<Answer> {
+    throw new ApiError(`answer n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
   /**
    * Récupérer les organisations d'une entitée : la liste des organisations dont l'entité est membre ou admin valide.
    * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN

package/src/api/Form.ts

@@ -119,4 +119,42 @@ export class Form extends BaseEntity<FormItemNormalized> {
       options
     );
   }
+
+  /**
+   * {@inheritDoc BaseEntity#answer}
+   *
+   * Crée une instance d'Answer **rattachée à ce Form**.
+   *
+   * - Si `answerData.id` est fourni → fetch l'Answer existante (via `COFORM_ANSWERS_BY_ID`).
+   * - Sinon → crée un draft d'Answer avec `form: this.id` pré-rempli, prêt à
+   *   être complété puis sauvegardé.
+   *
+   * Le parent de l'Answer renvoyée est ce Form — la chaîne `org > form > answer`
+   * est donc préservée, ce qui permet (à terme) à l'Answer de remonter le
+   * costumContext via `this.parent.parent` si besoin.
+   *
+   * @example
+   * // Fetch d'une Answer existante
+   * const form = await org.form({ id: "6925e2b05dd63b02ca70d6d9" });
+   * const answer = await form.answer({ id: "6925869ad76aaf6c5a2b2f8a" });
+   *
+   * // Création d'un draft
+   * const draft = await form.answer();
+   * draft.data.answers = { "field1": "value1" };
+   * await draft.save();
+   */
+  override async answer(answerData: Parameters<BaseEntity<FormItemNormalized>["answer"]>[0] = {}): Promise<Answer> {
+    if (!this.id) {
+      throw new ApiError("Form sans id, impossible de créer une Answer rattachée.", 400);
+    }
+
+    // Pré-remplit `form: this.id` uniquement pour les drafts (pas de fetch par id).
+    const hasId = typeof (answerData as { id?: string }).id === "string" && (answerData as { id: string }).id.length > 0;
+    const payload: Record<string, any> = hasId
+      ? answerData
+      : { form: this.id, ...answerData };
+
+    const entity = await this.entity("answers", payload);
+    return entity as Answer;
+  }
 }

package/src/api/Project.ts

@@ -386,11 +386,7 @@ export class Project extends BaseEntity<ProjectItemNormalized> {
     return super.badge(badgeData);
   }
 
-  /**
-   * {@inheritDoc BaseEntity#news}
-   *
-   * Crée une instance de news et la récupère si nécessaire.
-   */
+
   /**
    * {@inheritDoc BaseEntity#form}
    *
@@ -402,6 +398,11 @@ export class Project extends BaseEntity<ProjectItemNormalized> {
     return super.form(formData);
   }
 
+  /**
+   * {@inheritDoc BaseEntity#news}
+   *
+   * Crée une instance de news et la récupère si nécessaire.
+   */
   override async news(newsData: Parameters<BaseEntity<ProjectItemNormalized>["news"]>[0] = {}) {
     if(!newsData?.id && !this.isContributor()){
       throw new ApiError("Vous n'avez pas les droits pour créer une news dans ce projet", 403);

package/src/api/serverDataType/Answer.ts

@@ -64,6 +64,17 @@ export interface AnswerItemJson {
     [key: string]: unknown;
 }
 
+/**
+ * Raisons de refus d'édition côté backend, calculées par `coformAnswersById`
+ * et présentes dans la réponse normalisée. Utilisé par les UI pour distinguer
+ * les modes readonly/edit et afficher des messages contextuels.
+ */
+export type AnswerEditDeniedReason =
+    | "not_logged_in"
+    | "not_owner"
+    | "form_inactive"
+    | "form_closed";
+
 export interface AnswerItemNormalized {
     id: string;
     _id: ObjectID;
@@ -73,6 +84,7 @@ export interface AnswerItemNormalized {
     user?: string | User;
     links?: AnswerLinksBlock;
     draft?: boolean;
+    finished?: boolean;
     answers?: Record<string, unknown>;
     context?: ParentsMap | Record<string, Organization | Project>;
     form?: string;
@@ -83,5 +95,12 @@ export interface AnswerItemNormalized {
         date: Date;
     }>;
     project?: AnswerProjectRef;
+    /**
+     * L'utilisateur courant peut-il éditer cette réponse ? Calculé côté backend.
+     * Présent par défaut, ou enrichi avec le contexte si `formId` est fourni.
+     */
+    canEdit?: boolean;
+    /** Raison si `canEdit === false`. `null` si `canEdit === true`. */
+    editDeniedReason?: AnswerEditDeniedReason | null;
     [key: string]: unknown;
 }

package/types/api/Answer.d.ts

@@ -1,12 +1,140 @@
 import { BaseEntity } from "./BaseEntity.js";
 import type { AnswerItemNormalized } from "./serverDataType/Answer.js";
+import type { FormItemNormalized } from "./serverDataType/Form.js";
+type UploadInput = File | Blob | Buffer | import("stream").Readable;
+/**
+ * Format des données utilisateur d'un CoForm — `{ subFormId: { inputId: value } }`.
+ * Générique : la lib ne fait aucune supposition sur le type des valeurs.
+ */
+export type AllStepsData = Record<string, Record<string, unknown>>;
+/**
+ * Valeur d'un upload en attente — objet `{ name?, data: "data:...;base64,..." }`
+ * inséré par les inputs uploader avant le pré-upload backend.
+ */
+export interface PendingUploadValue {
+    name?: string;
+    data: string;
+}
+/**
+ * Un pending upload détecté dans la structure `allData` — chemin imbriqué +
+ * type d'input dérivé du schéma (`formData.inputs[subFormId].inputs[inputId].type`).
+ */
+export interface PendingUpload {
+    value: PendingUploadValue;
+    path: (string | number)[];
+    inputType?: string;
+}
+/**
+ * Options de `Answer.processUploads()`.
+ */
+export interface ProcessUploadsOptions {
+    /**
+     * Schéma du Form (pour déduire `inputType` des champs uploader/simpleTable).
+     * Auto-récupéré via `this.parent.serverData` si parent est un Form.
+     */
+    formData?: FormItemNormalized;
+    /** Nombre d'uploads parallèles par batch. Défaut : 4. */
+    batchSize?: number;
+}
+/**
+ * Options de `Answer.get()` — params optionnels du endpoint `COFORM_ANSWERS_BY_ID`.
+ */
+export interface AnswerGetOptions {
+    /**
+     * Liste de champs à retourner côté backend (filtrage). Si absent, tous les
+     * champs sont renvoyés. Utile pour optimiser la taille de la réponse.
+     */
+    fields?: string[];
+    /**
+     * ID du formulaire parent. Utilisé côté backend pour calculer `canEdit` et
+     * `editDeniedReason` (droits d'édition contextuels). Si absent, **auto-injecté
+     * via `this.parent.id`** quand le parent est un `Form` (cas typique
+     * `form.answer({id})`).
+     */
+    formId?: string;
+    /** Chemin Finder (rarement utilisé). */
+    finderPath?: string;
+}
+/**
+ * Options pour `Answer.uploadFile()`. Tous les champs sont optionnels — les
+ * défauts reproduisent les valeurs backend (`docType: "image"`, `contentKey: "slider"`).
+ */
+export interface UploadAnswerFileOptions {
+    /** Type de document : `image` (défaut) ou `file` (PDF, DOCX, etc.). */
+    docType?: "image" | "file";
+    /** Clé de contenu côté backend. `"slider"` (défaut) pour images, `"presentation"` pour inputs uploader. */
+    contentKey?: string;
+    /** Sous-clé optionnelle (ex: `"subFormId.inputId"` pour les inputs `*.uploader`). */
+    subKey?: string;
+    /** UUID client (compat fine-uploader). Auto-généré si absent. */
+    qquuid?: string;
+    /** Nom du fichier. Auto-déduit (File.name, stream.path, ou fallback) si absent. */
+    qqfilename?: string;
+    /**
+     * Taille du fichier en octets. Auto-déduite pour `File` (`.size`), `Blob`
+     * (`.size`), `Buffer` (`.length`), ou `Readable` annoté (`.size`).
+     *
+     * **À fournir explicitement pour un `Readable` non annoté** (ex:
+     * `fs.createReadStream(path)` → faire `fs.statSync(path).size` au préalable),
+     * sinon `0` est envoyé et le backend peut rejeter le multipart.
+     */
+    qqtotalfilesize?: number;
+}
+/**
+ * Retour normalisé de `Answer.uploadFile()`.
+ */
+export interface UploadAnswerFileResult {
+    /** ID du document MongoDB (à stocker dans `{docId, docPath}` pour les inputs uploader). */
+    docId: string;
+    /** Chemin du document. URL absolue côté backend, à nettoyer en chemin relatif si besoin (cf. `cleanUploaderUrls` site-json). */
+    docPath: string;
+    /** ID de l'Answer (créée par cet upload si premier, sinon `= this.id`). */
+    answerId: string;
+}
+/**
+ * Options de `Answer.getFiles()`.
+ */
+export interface GetFilesOptions {
+    /** Clé d'identification de l'input (ex: `"subFormId.inputId"`). Requise. */
+    subKey: string;
+    /** Type de document attendu. Défaut backend : `"file"`. */
+    docType?: "image" | "file";
+    /** Clé de contenu utilisée lors de l'upload. Défaut backend : `"presentation"`. */
+    contentKey?: string;
+}
+/**
+ * Élément renvoyé par `Answer.getFiles()` — un document attaché à l'Answer.
+ * Les champs `imagePath`/`imageThumbPath`/`imageMediumPath` ne sont présents
+ * que pour `docType: "image"`.
+ */
+export interface AnswerFileItem {
+    /** ID MongoDB du document (utilisable pour suppression via `deleteDocumentById`). */
+    docId: string;
+    /** Chemin relatif du document côté backend. */
+    docPath: string;
+    /** Nom original du fichier. */
+    name?: string;
+    /** Taille en octets. */
+    size?: number;
+    /** Chemin de l'image (uniquement si `docType: "image"`). */
+    imagePath?: string | null;
+    /** Chemin du thumbnail (uniquement si `docType: "image"`). */
+    imageThumbPath?: string | null;
+    /** Chemin de la version medium (uniquement si `docType: "image"`). */
+    imageMediumPath?: string | null;
+}
 export declare class Answer extends BaseEntity<AnswerItemNormalized> {
     static entityType: string;
     static entityTag: string;
     static SCHEMA_CONSTANTS: string[];
-    static ADD_BLOCKS: Map<string, string>;
-    static UPDATE_BLOCKS: Map<string, string>;
+    static ADD_BLOCKS: Map<"SAVE_COFORM_ANSWER", "saveCoformAnswer">;
+    static UPDATE_BLOCKS: Map<"SAVE_COFORM_ANSWER", "saveCoformAnswer">;
     defaultFields: Record<string, any>;
+    /**
+     * Champs `serverData` à ne pas renvoyer au serveur dans le payload de save.
+     * `answers`, `addedOptions`, `links`, `form` sont conservés (envoyés au serveur).
+     * Les autres sont calculés/posés par le backend.
+     */
     removeFields: string[];
     /**
      * Transforme les champs imbriqués (user, context etc.) en instances d'entités.
@@ -16,9 +144,291 @@ export declare class Answer extends BaseEntity<AnswerItemNormalized> {
      */
     protected _transformServerData(data: AnswerItemNormalized): AnswerItemNormalized;
     /**
-       * Rafraîchit les données de l'entité depuis l'API.
-       * Constant : COFORM_ANSWERS_BY_ID
-       */
-    get(): Promise<Record<string, any>>;
+     * Rafraîchit les données de l'entité depuis l'API (`COFORM_ANSWERS_BY_ID`).
+     *
+     * **Auto-injection du `formId`** : si le parent est un `Form` (cas typique
+     * `form.answer({id})`), le param `formId` est automatiquement envoyé pour
+     * que le backend calcule `canEdit` et `editDeniedReason` dans la réponse.
+     * Le caller peut override via `opts.formId` ou couper avec `opts.formId: ""`.
+     *
+     * @param opts - Params optionnels :
+     *  - `fields` : filtrage des champs côté backend
+     *  - `formId` : override de l'auto-injection (utile pour disable ou forcer un autre form)
+     *  - `finderPath` : chemin Finder (rare)
+     *
+     * @example
+     * // Cas commun : form.answer({id}) → get() auto avec formId
+     * const answer = await form.answer({ id: answerId });
+     * answer.serverData.canEdit;            // true/false calculé backend
+     * answer.serverData.editDeniedReason;   // raison si false
+     *
+     * @example
+     * // Cas avancé : filtrage de champs pour optim perf
+     * const answer = await form.answer();
+     * answer._id(answerId);
+     * await answer.get({ fields: ["answers", "canEdit", "editDeniedReason"] });
+     */
+    get(opts?: AnswerGetOptions): Promise<Record<string, any>>;
+    /**
+     * Récupère l'ID du parent Form si applicable, pour l'auto-injection dans `get()`.
+     * @private
+     */
+    private _autoFormIdFromParent;
     form(): Promise<never>;
+    /**
+     * Supprime cette Answer côté serveur via `DELETE_ELEMENT`
+     * (`type=answers`, `id=this.id`).
+     *
+     * Après succès :
+     *  - `serverData` et `draftData` sont vidés (sans casser la réactivité)
+     *  - `_isDeleted = true` → toute mutation ultérieure (`save`, `get`, etc.) throw
+     *
+     * @param reason - Raison libre transmise au backend (audit). Défaut : `"delete coform answer"`.
+     * @throws {ApiError} 400 si l'Answer n'a pas d'id (jamais sauvegardée).
+     *
+     * @example
+     * const answer = await form.answer({ id: "..." });
+     * await answer.delete();
+     * answer._isDeleted; // true
+     */
+    delete(reason?: string): Promise<void>;
+    /**
+     * Récupère la liste des fichiers attachés à un input précis de cette Answer
+     * via `COFORM_GET_ANSWER_FILES`.
+     *
+     * **Cas d'usage principal** : récupérer les fichiers d'inputs uploader stockés
+     * en **format legacy** `{updateDate: [...]}` (sans la clé `files`). Le backend
+     * recherche alors les documents MongoDB liés à `{answerId, subKey, docType}`.
+     *
+     * Pour les Answer en format moderne `{updateDate, files: {<docId>: <path>}}`,
+     * les fichiers sont déjà dans `answer.serverData.answers[subFormId][inputId].files`
+     * — pas besoin d'appel réseau.
+     *
+     * @param opts - `subKey` (requis, ex: `"subFormId.inputId"`), `docType`, `contentKey`
+     * @returns Liste normalisée des fichiers `{docId, docPath, name?, size?, imagePath?, imageThumbPath?, imageMediumPath?}`.
+     *          Tableau vide si aucun fichier trouvé.
+     * @throws {ApiError} 400 si pas d'id Answer. Throws aussi si le backend renvoie `result: false`.
+     *
+     * @example
+     * const form = await org.form({ id: formId });
+     * const answer = await form.answer({ id: answerId });
+     * const files = await answer.getFiles({
+     *   subKey: `${subFormId}.${inputId}`,
+     *   docType: "image",
+     * });
+     * files[0].docId;     // ID du document (pour suppression future)
+     * files[0].docPath;   // Chemin relatif (à concaténer avec baseURL pour affichage)
+     */
+    getFiles(opts: GetFilesOptions): Promise<AnswerFileItem[]>;
+    /**
+     * Upload un fichier rattaché à cette Answer via `COFORM_UPLOAD_ANSWER_FILE`.
+     *
+     * **Cas premier upload (Answer sans id)** : le backend crée l'Answer et
+     * renvoie `answerId`. La méthode pose alors `this._draftData.id = answerId`
+     * — les uploads suivants utiliseront cet id, et un `save()` ultérieur passera
+     * en update.
+     *
+     * **Cas uploads suivants (Answer avec id)** : `answerId: this.id` est envoyé.
+     *
+     * Compatible browser (File/Blob) et Node (Buffer/Readable) via
+     * `BaseEntity._prepareUploadFile()` — le multipart encoder du package
+     * `form-data` (utilisé en Node) ignore les Buffer bruts, donc conversion en
+     * stream annoté.
+     *
+     * @param file - Fichier à uploader (File/Blob côté browser, Buffer/Readable côté Node)
+     * @param opts - `docType`, `contentKey`, `subKey`, `qquuid`, `qqfilename`
+     * @returns `{ docId, docPath, answerId }` — toujours fournis par le backend.
+     * @throws {ApiError} si `formId` introuvable, ou réponse invalide.
+     *
+     * @example
+     * // Browser (depuis un <input type="file">)
+     * const form = await org.form({ id: formId });
+     * const answer = await form.answer();   // draft
+     * const { docId, docPath } = await answer.uploadFile(htmlFile, {
+     *   contentKey: "presentation",
+     *   subKey: `${subFormId}.${inputId}`,
+     * });
+     * // answer.id désormais défini → uploads suivants utilisent cet id.
+     *
+     * @example
+     * // Node (depuis un Buffer)
+     * const buffer = await fs.promises.readFile("./photo.jpg");
+     * const result = await answer.uploadFile(buffer, { docType: "image" });
+     */
+    uploadFile(file: UploadInput, opts?: UploadAnswerFileOptions): Promise<UploadAnswerFileResult>;
+    /**
+     * Orchestre l'upload de tous les fichiers pendants (`data:URI`) trouvés dans
+     * `allData`, puis renvoie la structure transformée prête pour `answer.save()`.
+     *
+     * **Pipeline complet** :
+     *  1. Walk récursif de `allData` → collecte les `data:URI` avec leur path + inputType
+     *  2. Premier upload (si Answer sans id) → backend crée l'Answer + pose `this.id`
+     *  3. Uploads restants en batches parallèles (défaut 4)
+     *  4. Remplacement dans la structure :
+     *     - inputs `*.uploader` → `{ docId, docPath }`
+     *     - autres → `docPath` string
+     *  5. Normalisation legacy uploader : `Array<{docId, docPath}>` → `{ updateDate, files }`
+     *  6. Nettoyage URLs absolues → chemins relatifs (uploader/simpleTable uniquement)
+     *
+     * Ne touche PAS `addedOptions` ni `links` — caller les pose séparément avant `save()`.
+     *
+     * @param allData - Données utilisateur `{ subFormId: { inputId: value } }`
+     * @param options - `formData` (auto via parent Form), `batchSize` (défaut 4)
+     * @returns `allData` transformé, prêt à être affecté à `answer.data.answers`
+     *
+     * @example
+     * const form = await org.form({ id: formId });
+     * const answer = await form.answer();   // ou form.answer({ id }) en édition
+     *
+     * const prepared = await answer.processUploads(allStepsDataFromForm);
+     * answer.data.answers = prepared;
+     * answer.data.addedOptions = addedOptions;   // optionnel
+     * answer.data.links = finderLinks;           // optionnel
+     * await answer.save();
+     */
+    processUploads(allData: AllStepsData, options?: ProcessUploadsOptions): Promise<AllStepsData>;
+    /**
+     * UUID v4 compatible browser + Node.
+     * Utilise `crypto.randomUUID()` si dispo, sinon fallback Math.random.
+     * @private
+     */
+    private _generateUuid;
+    /**
+     * Sauvegarde une nouvelle Answer (sans `id`) via `SAVE_COFORM_ANSWER`.
+     *
+     * Le payload caller-side attendu (dans `draftData`) :
+     *  - `answers` (requis) — objet `{ subFormId: { inputId: value } }`
+     *  - `form` ou parent Form (requis indirectement) — pour résoudre `formId`
+     *  - `addedOptions` (optionnel) — multiCheckboxPlus dynamiques
+     *  - `links` (optionnel) — sélections Finder à attacher à l'answer
+     *
+     * Sérialise automatiquement `answers`/`addedOptions`/`links` en JSON
+     * (le wire-format `application/x-www-form-urlencoded` exige des strings).
+     *
+     * Après succès, l'ID retourné par le serveur est posé dans `_draftData.id`
+     * → le `refresh()` de `BaseEntity.save()` peut alors récupérer l'Answer canonique.
+     *
+     * @protected — utiliser `answer.save()` (BaseEntity dispatch automatiquement).
+     */
+    _add: (payload: Record<string, any>) => Promise<void>;
+    /**
+     * Met à jour une Answer existante via `SAVE_COFORM_ANSWER` (avec `answerId`).
+     *
+     * Si `payload.answers` est `undefined` (le caller a modifié uniquement
+     * `addedOptions` ou `links`), on retombe sur `serverData.answers` pour ne
+     * pas envoyer un payload vide qui écraserait les réponses existantes.
+     *
+     * @protected — utiliser `answer.save()`.
+     */
+    _update: (payload: Record<string, any>) => Promise<boolean>;
+    /**
+     * Résout le `formId` à envoyer à `saveCoformAnswer`.
+     *
+     * Priorité :
+     *   1. `payload.form` (posé via `draftData.form` par `form.answer()`)
+     *   2. `serverData.form` (Answer chargée via `get()`)
+     *   3. `this.parent.id` si le parent est un `Form`
+     *
+     * @throws {ApiError} 400 si aucune source ne fournit un formId valide.
+     * @private
+     */
+    private _resolveFormId;
+    /**
+     * Construit le payload `SaveCoformAnswerData` en sérialisant les champs JSON
+     * requis par le wire-format `application/x-www-form-urlencoded`.
+     *
+     * Si `payload.answers` est absent en update, retombe sur `serverData.answers`
+     * (cf. design point 6.5 — indulgent envers le caller).
+     *
+     * @private
+     */
+    private _buildSavePayload;
+    /**
+     * Récupère `formData` (schéma du Form) depuis le parent si c'est un Form.
+     * Renvoie `undefined` si pas exploitable — `processUploads` continuera mais
+     * sans détection automatique d'`inputType` (pas de normalisation uploader,
+     * pas de clean URLs).
+     * @private
+     */
+    private _resolveFormData;
+    private _isObjectRecord;
+    private _isDataUri;
+    private _isPendingUploadValue;
+    private _parseMimeType;
+    private _inferExtensionFromMimeType;
+    private _sanitizeBaseName;
+    /**
+     * Convertit un `PendingUploadValue` (data:URI) en `{file, docType, filename}`
+     * exploitable par `uploadFile()`. Compatible browser + Node :
+     *  - Browser → `File` natif
+     *  - Node → `Buffer` (sera converti en stream par `_prepareUploadFile()`)
+     * @private
+     */
+    private _dataUriToFile;
+    /**
+     * Parcourt récursivement `allData` pour trouver tous les `data:URI` à uploader.
+     * Renvoie chaque pending avec son `path` (chemin imbriqué) et `inputType`
+     * (déduit du schéma `formData` si fourni).
+     * @private
+     */
+    private _collectPendingUploads;
+    /**
+     * Détermine `contentKey` et `subKey` pour un upload selon le type d'input :
+     *  - `*.uploader` → `presentation` + subKey `"subFormId.inputId"`
+     *  - autres → `slider` sans subKey
+     * @private
+     */
+    private _getUploadKeys;
+    private _getValueAtPath;
+    private _setValueAtPath;
+    /**
+     * Walk les `answers[subFormId][inputId]` pour normaliser les valeurs des
+     * inputs `*.uploader` vers le format canonique `{updateDate, files: {docId: docPath}}`.
+     *
+     * Utilisé par `_transformServerData()` pour harmoniser les Answer en format
+     * legacy Array `[{docId, docPath}]` avec le format moderne (ce que
+     * `processUploads()` écrit).
+     *
+     * Skip si le schéma `formData` n'a pas l'inputType pour un champ donné.
+     * @private
+     */
+    private _normalizeLegacyUploaderInAnswers;
+    /**
+     * Normalise une valeur d'input uploader vers le format legacy backend :
+     *   `{ updateDate: ["DD/MM/YYYY"], files: { "<docId>": "<docPath>", ... } }`
+     * @private
+     */
+    private _normalizeUploaderValue;
+    private _cleanUrlToRelativePath;
+    /**
+     * Suffixes de types d'inputs dont les valeurs contiennent des URLs de fichiers
+     * à nettoyer avant envoi au serveur.
+     * @private
+     */
+    private static readonly INPUT_TYPES_TO_CLEAN_URLS;
+    /**
+     * Nettoie les URLs absolues → chemins relatifs **uniquement** sur les champs
+     * uploader/simpleTable. Les autres champs (finder, text…) peuvent contenir
+     * des URLs légitimes qu'il ne faut pas tronquer.
+     * @private
+     */
+    private _cleanUploaderUrls;
+    /**
+     * Upload par batches parallèles (défaut : 4 fichiers simultanés).
+     * @private
+     */
+    private _uploadInBatches;
+    /**
+     * Upload un PendingUpload, retourne la valeur de remplacement à insérer
+     * dans `allData` (`{docId, docPath}` pour uploader, `docPath` string sinon).
+     * @private
+     */
+    private _uploadPendingItem;
+    /**
+     * Upload un PendingUpload + remplace immédiatement dans `prepared` à son path.
+     * Utilisé pour le premier upload (séquentiel) qui crée l'Answer.
+     * @private
+     */
+    private _uploadAndReplace;
 }
+export {};