# General Translation Platform: downloadFileBatch
URL: https://generaltranslation.com/fr/docs/platform/core/reference/gt-class-methods/translation/download-file-batch.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Télécharge plusieurs fichiers traduits par lots. Référence API de downloadFileBatch.

Récupérez des fichiers source ou de traduction par lots de 100 au maximum au lieu de multiplier les appels individuels à [`downloadFile`](/docs/platform/core/reference/gt-class-methods/translation/download-file), ce qui réduit la surcharge réseau.

## Vue d’ensemble [#overview]

Appelez `downloadFileBatch` avec un tableau de requêtes de fichier. Chaque requête peut cibler une traduction (avec un `locale`) ou un fichier source (sans `locale`).

```typescript
const gt = new GT({ projectId: 'your-project-id', apiKey: 'your-api-key' });

const result = await gt.downloadFileBatch([
  { fileId: 'file-123', branchId: 'branch-456', locale: 'es' },
  { fileId: 'file-123', branchId: 'branch-456', locale: 'fr' },
  { fileId: 'file-123', branchId: 'branch-456', locale: 'de' },
]);
```

Signature :

```typescript
downloadFileBatch(
  requests: DownloadFileBatchRequest,
  options?: DownloadFileBatchOptions
): Promise<DownloadFileBatchResult>
```

*Remarque : `downloadFileBatch` nécessite une clé API (y compris l’alias déprécié `devApiKey`), ainsi que `projectId` sur l’instance GT. Par défaut, les lots s’exécutent en parallèle.*

## Fonctionnement [#how-it-works]

* **Ordre.** Associez chaque résultat à sa requête à l’aide de ses `fileId`, `branchId`, `versionId` et `locale`, plutôt qu’à sa position dans la réponse.
* **Codes de langue.** Si une seule des graphies ou un seul des alias demandés correspond à un paramètre régional renvoyé, c’est cette graphie qui est utilisée. Sinon, les paramètres régionaux renvoyés suivent les [règles du constructeur](/docs/platform/core/reference/gt-class/constructor#how-it-works). Des graphies demandées équivalentes peuvent partager une même étiquette dans la réponse.
* **Succès partiel.** Une réponse réussie peut contenir moins de fichiers que demandé. Le rejet d’une requête par lots entraîne le rejet du résultat agrégé, sans annuler ni interrompre les lots déjà lancés.
* **Disponibilité.** Utilisez [`queryFileData`](/docs/platform/core/reference/gt-class-methods/translation/query-file-data) pour vérifier que les fichiers sont prêts avant de les télécharger.
* **Formats binaires.** Les formats texte renvoient des données UTF-8 décodées. `LOTTIE` reste encodé en base64 afin que les appelants puissent reconstruire le fichier binaire `.lottie` sans corrompre ses octets.

## Paramètres [#parameters]

| Paramètre               | Description                                    | Type                       | Facultatif | Par défaut |
| ----------------------- | ---------------------------------------------- | -------------------------- | ---------- | ---------- |
| [`requests`](#requests) | Tableau d’objets de requête de fichier.        | `DownloadFileBatchRequest` | Non        | —          |
| [`options`](#options)   | Configuration de la requête de téléchargement. | `DownloadFileBatchOptions` | Oui        | —          |

### `requests` [#requests]

**Type** `DownloadFileBatchRequest` · **Obligatoire**

Un tableau de requêtes de fichiers :

```typescript
type DownloadFileBatchRequest = {
  fileId: string;
  branchId?: string;
  locale?: string;
  versionId?: string;
  useLatestAvailableVersion?: boolean;
}[];
```

| Champ                       | Description                                                                                                                           | Type      | Facultatif | Valeur par défaut  |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------- | ---------- | ------------------ |
| `fileId`                    | Identifiant unique du fichier à télécharger.                                                                                          | `string`  | Non        | —                  |
| `branchId`                  | Branche depuis laquelle télécharger.                                                                                                  | `string`  | Oui        | branche par défaut |
| `locale`                    | Paramètre régional cible de la traduction. Omettez-le pour télécharger le fichier source.                                             | `string`  | Oui        | —                  |
| `versionId`                 | ID de version à télécharger.                                                                                                          | `string`  | Oui        | dernière version   |
| `useLatestAvailableVersion` | Si `true` et que le `versionId` spécifié est introuvable, la dernière version disponible est utilisée au lieu de renvoyer une erreur. | `boolean` | Oui        | `false`            |

### `options` [#options]

**Type** `DownloadFileBatchOptions` · **Facultatif**

| Champ     | Description                                         | Type     | Facultatif |
| --------- | --------------------------------------------------- | -------- | ---------- |
| `timeout` | Délai d’expiration de la requête, en millisecondes. | `number` | Oui        |

## Retour [#returns]

**Type** `Promise<DownloadFileBatchResult>`

La promesse se résout en un `DownloadFileBatchResult` contenant les fichiers téléchargés et leur nombre, mais sans les détails `pending`. Pour obtenir ces derniers, utilisez la fonction générée `downloadFiles` via le [client API](/docs/platform/core/reference/api-client#endpoint-helpers), qui renvoie le contenu en base64 :

```typescript
type DownloadFileBatchResult = {
  files: DownloadedFile[];
  count: number;
};

type DownloadedFile = {
  id: string;
  branchId: string;
  fileId: string;
  versionId: string;
  locale?: string; // présent lorsque le fichier est une traduction
  fileName?: string; // présent pour les fichiers source (lorsque le paramètre régional est absent)
  data: string; // texte UTF-8, ou base64 pour les formats binaires
  metadata: JsonObject;
  fileFormat: FileFormat;
};
```

| Propriété            | Description                                                                                         | Type                                                            |
| -------------------- | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| `files`              | Tableau d’objets de fichiers téléchargés.                                                           | `DownloadedFile[]`                                              |
| `count`              | Nombre de fichiers téléchargés avec succès.                                                         | `number`                                                        |
| `files[].id`         | Identifiant unique de l’enregistrement du fichier téléchargé.                                       | `string`                                                        |
| `files[].branchId`   | ID de branche.                                                                                      | `string`                                                        |
| `files[].fileId`     | ID de fichier.                                                                                      | `string`                                                        |
| `files[].versionId`  | ID de version.                                                                                      | `string`                                                        |
| `files[].locale`     | Paramètre régional du fichier, présent s’il s’agit d’une traduction.                                | `string` (optional)                                             |
| `files[].fileName`   | Nom du fichier d’origine, présent pour les fichiers source.                                         | `string` (optional)                                             |
| `files[].data`       | Contenu UTF-8 du fichier pour les formats texte, ou contenu binaire encodé en base64 pour `LOTTIE`. | `string`                                                        |
| `files[].metadata`   | Métadonnées spécifiques au format du fichier.                                                       | `JsonObject`                                                    |
| `files[].fileFormat` | Format du fichier (`JSON`, `MDX`, etc.).                                                            | [`FileFormat`](/docs/platform/core/reference/types/file-format) |

## Exemples [#examples]

```typescript title="index.ts"
import { GT } from 'generaltranslation';
import type { FileUpload } from 'generaltranslation/types';

const fileContents = '{"greeting":"Hello"}';
const filePath = 'en.json';

// (1) Créer une instance GT
const targetLocales = ['es', 'fr', 'de'];
const gt = new GT({
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
});

// (2) Téléverser le fichier
const fileUpload: FileUpload = {
  content: fileContents,
  fileName: filePath,
  fileFormat: 'JSON',
  locale: 'en',
};
const files = [{ source: fileUpload }];
const { uploadedFiles } = await gt.uploadSourceFiles(files, { sourceLocale: 'en' });

// (3) Mettre en file d'attente le job de traduction du fichier
const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: targetLocales,
});

// (4) Attendre que toutes les traductions soient terminées
const { fileId, versionId, branchId } = uploadedFiles[0];
const result = await gt.awaitJobs(enqueueResult, { timeoutSeconds: 300 });

if (!result.complete || result.jobs.some((job) => job.status !== 'completed')) {
  throw new Error('Translations are not ready to download');
}

// (5) Télécharger toutes les traductions par lots
const downloadResult = await gt.downloadFileBatch(
  targetLocales.map((locale) => ({
    fileId,
    versionId,
    branchId,
    locale,
  }))
);

downloadResult.files.forEach((file) => {
  console.log(`Downloaded ${file.locale}: ${file.fileName}`);
});
```

## Remarques [#notes]

* Les fichiers texte sont renvoyés sous forme de chaînes de caractères UTF-8. Décodez les données `LOTTIE` depuis le format base64 pour écrire le fichier binaire `.lottie`.
* Utilisez [`queryFileData`](/docs/platform/core/reference/gt-class-methods/translation/query-file-data) pour vérifier au préalable que les fichiers sont prêts à être téléchargés.
* Faites correspondre les résultats aux requêtes à l’aide de leurs identifiants de fichier, de version, de branche et de paramètre régional plutôt que selon leur position.
* Une réponse partiellement réussie n’est pas un échec de requête : le rejet d’une requête par lots entraîne le rejet du résultat agrégé.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.
