# generaltranslation: General Translation Core SDK: uploadTranslations
URL: https://generaltranslation.com/fr/docs/core/class/methods/translation/upload-translations.mdx
---
title: uploadTranslations
description: Référence de l’API pour la méthode uploadTranslations permettant de téléverser des fichiers de traduction existants
---

## Vue d’ensemble

La méthode `uploadTranslations` téléverse des fichiers de traduction correspondant à des fichiers source précédemment téléversés.
C’est utile lorsque vous disposez déjà de traductions que vous souhaitez téléverser directement au lieu de les générer via le service de traduction.

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

const result = await gt.uploadTranslations(files, {
  sourceLocale: 'en'
});
```

<Callout type="info">
  Vous devez d’abord avoir téléversé les fichiers source à l’aide de [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files) avant de téléverser les traductions.
</Callout>

## Référence

### Paramètres

| Nom       | Type                  | Description                                                      |
| --------- | --------------------- | ---------------------------------------------------------------- |
| `files`   | `TranslationUpload[]` | Tableau de références aux fichiers source avec leurs traductions |
| `options` | `UploadFilesOptions`  | Options de configuration du téléversement                        |

#### Structure de TranslationUpload

```typescript
type TranslationUpload = {
  source: FileUpload;      // Référence au fichier source existant (aucun contenu requis)
  translations: FileUpload[]; // Tableau des fichiers traduits avec leur contenu
}
```


#### Structure de FileUpload (pour référence côté source)

| Nom          | Type         | Description                                                           |
| ------------ | ------------ | --------------------------------------------------------------------- |
| `fileName`   | `string`     | Nom du fichier correspondant au fichier source précédemment téléversé |
| `fileFormat` | `FileFormat` | Format du fichier (JSON, MDX, MD, XML, etc.)                          |
| `fileId?`    | `string`     | ID facultatif du fichier source                                       |
| `versionId?` | `string`     | ID facultatif de la version du fichier source                         |

#### Structure `FileUpload` (pour les traductions)

| Nom          | Type         | Description                                           |
| ------------ | ------------ | ----------------------------------------------------- |
| `content`    | `string`     | Contenu brut du fichier traduit, sous forme de chaîne |
| `fileName`   | `string`     | Nom du fichier de traduction                          |
| `fileFormat` | `FileFormat` | Format du fichier (JSON, MDX, MD, XML, etc.)          |
| `locale`     | `string`     | Paramètre régional cible de la traduction             |
| `fileId?`    | `string`     | ID de fichier facultatif                              |
| `versionId?` | `string`     | ID de version facultatif                              |

#### UploadFilesOptions

| Nom            | Type     | Description                                       |
| -------------- | -------- | ------------------------------------------------- |
| `sourceLocale` | `string` | Le paramètre régional d’origine des fichiers      |
| `branchId?`    | `string` | ID de branche facultatif pour le téléversement    |
| `timeout?`     | `number` | Délai d’expiration de la requête en millisecondes |

### Renvoie

`Promise<UploadFilesResponse>` - Contient les résultats du téléversement et les références aux fichiers.

```typescript
type UploadFilesResponse = {
  uploadedFiles: FileReference[];
  count: number;
  message: string;
}
```

| Propriété       | Type              | Description                                   |
| --------------- | ----------------- | --------------------------------------------- |
| `uploadedFiles` | `FileReference[]` | Tableau des références des fichiers téléversés |
| `count`         | `number`          | Nombre de fichiers téléversés avec succès      |
| `message`       | `string`          | Message d’état renvoyé par l’API            |

***


## Exemples

### Utilisation de base

Téléversez les traductions des fichiers source déjà téléversés :

```typescript copy
import { GT } from 'generaltranslation';
import fs from 'fs';

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

// Supposons que le fichier source a déjà été uploadé
const files = [
  {
    source: {
      fileName: 'common.json',
      fileFormat: 'JSON' as const,
      fileId: 'source-file-id',
      versionId: 'source-version-id'
    },
    translations: [
      {
        content: fs.readFileSync('./locales/es/common.json', 'utf8'),
        fileName: 'common.json',
        fileFormat: 'JSON' as const,
        locale: 'es'
      },
      {
        content: fs.readFileSync('./locales/fr/common.json', 'utf8'),
        fileName: 'common.json',
        fileFormat: 'JSON' as const,
        locale: 'fr'
      }
    ]
  }
];

const result = await gt.uploadTranslations(files, {
  sourceLocale: 'en'
});

console.log(`Uploaded ${result.count} translation files`);
```


### Téléversement après le téléversement des fichiers source

Workflow complet : téléversez d’abord les fichiers source, puis les traductions :

```typescript copy
import { GT } from 'generaltranslation';
import fs from 'fs';

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

// Étape 1 : Upload des fichiers source
const sourceFiles = [
  {
    source: {
      content: fs.readFileSync('./locales/en/messages.json', 'utf8'),
      fileName: 'messages.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  }
];

const { uploadedFiles } = await gt.uploadSourceFiles(sourceFiles, {
  sourceLocale: 'en'
});

// Étape 2 : Upload des traductions existantes
const translationFiles = [
  {
    source: {
      fileName: uploadedFiles[0].fileName,
      fileFormat: uploadedFiles[0].fileFormat,
      fileId: uploadedFiles[0].fileId,
      versionId: uploadedFiles[0].versionId
    },
    translations: [
      {
        content: fs.readFileSync('./locales/es/messages.json', 'utf8'),
        fileName: 'messages.json',
        fileFormat: 'JSON' as const,
        locale: 'es'
      },
      {
        content: fs.readFileSync('./locales/de/messages.json', 'utf8'),
        fileName: 'messages.json',
        fileFormat: 'JSON' as const,
        locale: 'de'
      }
    ]
  }
];

const translationResult = await gt.uploadTranslations(translationFiles, {
  sourceLocale: 'en'
});

console.log(`${translationResult.count} traductions envoyées`);
```


### Téléversement groupé de plusieurs fichiers

Téléversez les traductions pour plusieurs fichiers source :

```typescript copy
import { glob } from 'glob';
import path from 'path';

async function uploadAllTranslations(
  sourceRefs: FileReference[],
  targetLocales: string[]
) {
  const files = sourceRefs.map(sourceRef => ({
    source: {
      fileName: sourceRef.fileName,
      fileFormat: sourceRef.fileFormat,
      fileId: sourceRef.fileId,
      versionId: sourceRef.versionId
    },
    translations: targetLocales
      .map(locale => {
        const translationPath = `./locales/${locale}/${sourceRef.fileName}`;
        try {
          return {
            content: fs.readFileSync(translationPath, 'utf8'),
            fileName: sourceRef.fileName,
            fileFormat: sourceRef.fileFormat,
            locale
          };
        } catch {
          // Le fichier de traduction n'existe pas pour ce paramètre régional
          return null;
        }
      })
      .filter(Boolean)
  }));

  const result = await gt.uploadTranslations(files, {
    sourceLocale: 'en',
    timeout: 60000
  });

  return result;
}
```

***


## Remarques

* Les fichiers source doivent d’abord être téléversés à l’aide de [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files)
* L’objet `source` de chaque entrée de fichier est une référence à un fichier source existant (le contenu n’est pas requis)
* Chaque traduction du tableau `translations` doit inclure un contenu et un paramètre régional cible
* Cette méthode est utile pour migrer des traductions existantes ou téléverser des traductions révisées manuellement
* Les références de fichier incluent `branchId` pour assurer un versionnage correct avec la prise en charge des branches

## Étapes suivantes

* Consultez [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files) pour commencer par téléverser les fichiers source
* Consultez [`enqueueFiles`](/docs/core/class/methods/translation/enqueue-files) pour générer automatiquement les traductions
* Consultez [`downloadFile`](/docs/core/class/methods/translation/download-file) pour télécharger les traductions
* Consultez [`queryFileData`](/docs/core/class/methods/translation/query-file-data) pour vérifier l’état des traductions