# generaltranslation: General Translation Core SDK: uploadSourceFiles
URL: https://generaltranslation.com/fr/docs/core/class/methods/translation/upload-source-files.mdx
---
title: uploadSourceFiles
description: Référence de l’API pour la méthode uploadSourceFiles, qui permet de téléverser des fichiers source à traduire
---

## Vue d’ensemble

La méthode `uploadSourceFiles` téléverse les fichiers source vers la plateforme General Translation pour traitement.
Il s’agit généralement de la première étape d’un workflow de traduction, avant de configurer des projets ou de mettre des tâches de traduction en file d’attente.

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

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

<Mermaid
  chart="
graph TD;
A[uploadSourceFiles];
B[setupProject];
C[enqueueFiles];
E[queryFileData];
F[downloadFileBatch];
A --> B;
B --> C;
C --> E;
E --> F;
"
/>


## Référence

### Paramètres

| Nom       | Type                       | Description                                  |
| --------- | -------------------------- | -------------------------------------------- |
| `files`   | `{ source: FileUpload }[]` | Tableau des fichiers source à téléverser     |
| `options` | `UploadFilesOptions`       | Options de configuration pour le téléversement |

#### Structure de `FileUpload`

| Nom           | Type         | Description                                                                 |
| ------------- | ------------ | --------------------------------------------------------------------------- |
| `content`     | `string`     | Contenu brut du fichier sous forme de chaîne                                |
| `fileName`    | `string`     | Identifiant unique du fichier (généralement le chemin et le nom du fichier) |
| `fileFormat`  | `FileFormat` | Format du fichier (JSON, MDX, MD, XML, etc.)                                |
| `dataFormat?` | `DataFormat` | Format facultatif des données dans le fichier (ICU, I18NEXT, JSX)           |
| `locale`      | `string`     | Paramètre régional du contenu du fichier source                             |
| `versionId?`  | `string`     | ID de version facultatif pour les cas d&#39;utilisation avancés             |
| `fileId?`     | `string`     | ID de fichier facultatif pour les cas d&#39;utilisation avancés             |

#### UploadFilesOptions

| Nom              | Type     | Description                                                  |
| ---------------- | -------- | ------------------------------------------------------------ |
| `sourceLocale`   | `string` | Le paramètre régional source de tous les fichiers téléversés |
| `branchId?`      | `string` | ID de branche facultatif vers laquelle téléverser            |
| `modelProvider?` | `string` | Préférence facultative pour le fournisseur de modèle d’IA    |
| `timeout?`       | `number` | Délai d’expiration de la requête, en millisecondes           |

### Retourne

`Promise<UploadFilesResponse>` - Contient les résultats du téléversement et les références des 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 pour les opérations suivantes |
| `count`         | `number`          | Nombre de fichiers téléversés avec succès                                    |
| `message`       | `string`          | Message d’état renvoyé par l’API                                             |


#### Structure de FileReference

```typescript
type FileReference = {
  fileId: string;
  versionId: string;
  branchId: string;
  fileName: string;
  fileFormat: FileFormat;
  dataFormat?: DataFormat;
  locale?: string;
}
```

***


## Exemples

### Utilisation de base

Téléversez des fichiers de traduction JSON :

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

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

const files = [
  {
    source: {
      content: fs.readFileSync('./locales/en/common.json', 'utf8'),
      fileName: 'common.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  },
  {
    source: {
      content: fs.readFileSync('./locales/en/navigation.json', 'utf8'),
      fileName: 'navigation.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  }
];

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

console.log(`Uploaded ${result.count} files`);
result.uploadedFiles.forEach(file => {
  console.log(`  ${file.fileName}: ${file.fileId} (branch: ${file.branchId})`);
});
```


### Avec un format de données explicite

Téléversez des fichiers en précisant explicitement leur format de données :

```typescript copy
const files = [
  {
    source: {
      content: '{"welcome": "Welcome, {name}!"}',
      fileName: 'messages.json',
      fileFormat: 'JSON' as const,
      dataFormat: 'ICU' as const, // format de message ICU
      locale: 'en'
    }
  },
  {
    source: {
      content: '{"greeting": "Hello {{name}}"}',
      fileName: 'i18next.json',
      fileFormat: 'JSON' as const,
      dataFormat: 'I18NEXT' as const,
      locale: 'en'
    }
  }
];

const result = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en',
  modelProvider: 'gpt-4',
  timeout: 30000
});
```


### Téléversement par lot avec gestion des erreurs

Téléversez plusieurs fichiers avec une gestion complète des erreurs :

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

async function uploadAllJsonFiles() {
  try {
    // Trouver tous les fichiers JSON
    const jsonPaths = await glob('./locales/en/**/*.json');

    const files = jsonPaths.map(filePath => ({
      source: {
        content: fs.readFileSync(filePath, 'utf8'),
        fileName: path.relative('./locales/en', filePath),
        fileFormat: 'JSON' as const,
        locale: 'en'
      }
    }));

    console.log(`Téléversement de ${files.length} fichiers en cours...`);

    const result = await gt.uploadSourceFiles(files, {
      sourceLocale: 'en',
      timeout: 60000 // délai d'expiration de 60 secondes pour les téléversements volumineux
    });

    if (result.count !== files.length) {
      console.warn(`${files.length} fichiers attendus, mais seulement ${result.count} téléversés`);
    }

    return result.uploadedFiles;

  } catch (error) {
    console.error('Échec du téléversement :', error);
    throw error;
  }
}

const uploadedFiles = await uploadAllJsonFiles();
```

***


## Remarques

* Le contenu du fichier est automatiquement encodé en Base64 pour être transmis en toute sécurité
* Les noms de fichier doivent être des identifiants uniques, généralement composés du chemin du fichier
* Le champ `locale` de chaque fichier doit correspondre à l’option `sourceLocale`
* Les fichiers volumineux ou un grand nombre de fichiers peuvent nécessiter des délais d’expiration plus élevés
* Les références de fichier renvoyées par cette méthode sont nécessaires pour les opérations ultérieures
* Les références de fichier incluent `branchId` pour assurer un versionnage correct avec la prise en charge des branches
* Les formats de fichier pris en charge incluent JSON, MD, MDX, XML et d’autres formats ; consultez le type `FileFormat` pour la liste complète

## Étapes suivantes

* Consultez [`setupProject`](/docs/core/class/methods/translation/setup-project) pour préparer les fichiers téléversés à la traduction
* Consultez [`enqueueFiles`](/docs/core/class/methods/translation/enqueue-files) pour lancer des tâches de traduction
* Consultez [`uploadTranslations`](/docs/core/class/methods/translation/upload-translations) pour téléverser des traductions existantes
* Consultez `FileUpload` pour plus de détails sur la structure des fichiers