# generaltranslation: General Translation Core SDK: uploadTranslations
URL: https://generaltranslation.com/es/docs/core/class/methods/translation/upload-translations.mdx
---
title: uploadTranslations
description: Referencia de la API del método uploadTranslations para cargar archivos de traducción existentes
---

## Resumen

El método `uploadTranslations` carga archivos de traducción que corresponden a archivos de origen cargados previamente.
Esto resulta útil cuando ya tienes traducciones existentes y quieres cargarlas directamente, en lugar de generarlas mediante el servicio de traducción.

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

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

<Callout type="info">
  Debes haber cargado previamente los archivos de origen con [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files) antes de cargar las traducciones.
</Callout>

## Referencia

### Parámetros

| Nombre    | Tipo                  | Descripción                                                    |
| --------- | --------------------- | -------------------------------------------------------------- |
| `files`   | `TranslationUpload[]` | Array de referencias a archivos de origen con sus traducciones |
| `options` | `UploadFilesOptions`  | Opciones de configuración para la carga                        |

#### Estructura de TranslationUpload

```typescript
type TranslationUpload = {
  source: FileUpload;      // Referencia al archivo de origen existente (no se necesita contenido)
  translations: FileUpload[]; // Array de archivos traducidos con contenido
}
```

#### Estructura de FileUpload (como referencia del original)

| Nombre       | Tipo         | Descripción                                                                  |
| ------------ | ------------ | ---------------------------------------------------------------------------- |
| `fileName`   | `cadena`     | Nombre del archivo que coincide con el archivo de origen cargado previamente |
| `fileFormat` | `FileFormat` | Formato del archivo (JSON, MDX, MD, XML, etc.)                               |
| `fileId?`    | `cadena`     | ID opcional del archivo de origen                                            |
| `versionId?` | `cadena`     | ID de versión opcional del archivo de origen                                 |

#### Estructura de FileUpload (para traducciones)

| Nombre       | Tipo         | Descripción                                                    |
| ------------ | ------------ | -------------------------------------------------------------- |
| `content`    | `string`     | Contenido sin procesar del archivo traducido como una `cadena` |
| `fileName`   | `string`     | Nombre del archivo de la traducción                            |
| `fileFormat` | `FileFormat` | Formato del archivo (JSON, MDX, MD, XML, etc.)                 |
| `locale`     | `string`     | Configuración regional de destino de la traducción             |
| `fileId?`    | `string`     | ID de archivo opcional                                         |
| `versionId?` | `string`     | ID de versión opcional                                         |

#### UploadFilesOptions

| Nombre         | tipo     | Descripción                                              |
| -------------- | -------- | -------------------------------------------------------- |
| `sourceLocale` | `string` | La configuración regional de origen para los archivos    |
| `branchId?`    | `string` | ID opcional de la rama a la que se cargarán los archivos |
| `timeout?`     | `number` | Tiempo de espera de la solicitud en milisegundos         |

### Devuelve

`Promise<UploadFilesResponse>` - Contiene los resultados de la carga y las referencias a archivos.

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

| Propiedad       | Tipo              | Descripción                               |
| --------------- | ----------------- | ----------------------------------------- |
| `uploadedFiles` | `FileReference[]` | array de referencias a archivos cargados  |
| `count`         | `number`          | Número de archivos cargados correctamente |
| `message`       | `string`          | Mensaje de estado de la API               |

***


## Ejemplos

### Uso básico

Carga traducciones para archivos de origen cargados previamente:

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

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

// Se asume que el archivo de origen fue cargado previamente
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`);
```

### Cargar después de cargar el origen

Flujo de trabajo completo: primero carga los archivos de origen y luego las traducciones:

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

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

// Paso 1: Cargar archivos de origen
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'
});

// Paso 2: Cargar traducciones existentes
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(`Se cargaron ${translationResult.count} traducciones`);
```


### Carga por lotes de varios archivos

Carga traducciones para varios archivos de origen:

```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 {
          // El archivo de traducción no existe para esta configuración regional
          return null;
        }
      })
      .filter(Boolean)
  }));

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

  return result;
}
```

***

## Notas

* Los archivos fuente deben cargarse primero con [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files)
* El objeto `source` en cada entrada de archivo es una referencia a un archivo de origen existente (no se necesita el contenido)
* Cada traducción del array `translations` debe incluir contenido y una configuración regional de destino
* Este método es útil para migrar traducciones existentes o cargar traducciones revisadas manualmente
* Las referencias a archivo incluyen `branchId` para un control de versiones correcto con compatibilidad con el uso de ramas

## Próximos pasos

* Consulta [`uploadSourceFiles`](/docs/core/class/methods/translation/upload-source-files) para cargar primero los archivos de origen
* Consulta [`enqueueFiles`](/docs/core/class/methods/translation/enqueue-files) para generar traducciones automáticamente
* Consulta [`downloadFile`](/docs/core/class/methods/translation/download-file) para descargar las traducciones
* Consulta [`queryFileData`](/docs/core/class/methods/translation/query-file-data) para comprobar el estado de la traducción