# General Translation Platform: uploadTranslations
URL: https://generaltranslation.com/es/docs/platform/core/reference/gt-class-methods/translation/upload-translations.mdx
---

title: uploadTranslations
description: Sube archivos traducidos existentes que corresponden a archivos fuente. Referencia de la API para uploadTranslations.

---

Sube archivos de traducción que corresponden a archivos fuente subidos previamente. Úsalo con General Translation cuando ya tengas traducciones —por ejemplo, al migrar traducciones existentes o subir traducciones revisadas por personas— en lugar de generarlas mediante el servicio de traducción.

## Resumen general [#overview]

Llama a `uploadTranslations` con una lista de cargas de traducción y un objeto de opciones. Cada carga hace referencia a un archivo fuente existente y contiene uno o más archivos traducidos.

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

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

Firma:

```typescript
uploadTranslations(
  files: { source: FileUpload; translations: FileUpload[] }[],
  options: UploadFilesOptions
): Promise<UploadFilesResponse>
```

*Nota: `uploadTranslations` requiere una `apiKey` (o `devApiKey`) y `projectId` en la instancia de GT. Primero debes subir los archivos fuente correspondientes con [`uploadSourceFiles`](/docs/platform/core/reference/gt-class-methods/translation/upload-source-files).*

## Cómo funciona [#how-it-works]

* **Referencia al origen.** El objeto `source` de cada entrada es una referencia a un archivo fuente ya subido; su contenido no es necesario.
* **Traducciones.** Cada elemento de la lista `translations` debe incluir contenido y una configuración regional de destino.
* **Control de versiones.** Las referencias de archivo devueltas incluyen `branchId` para el control de versiones con soporte para ramas.

## Parámetros [#parameters]

| Parámetro             | Descripción                                                            | Tipo                                                   | Opcional | Predeterminado |
| --------------------- | ---------------------------------------------------------------------- | ------------------------------------------------------ | -------- | -------------- |
| [`files`](#files)     | Array de referencias de archivos fuente junto con sus traducciones. | `{ source: FileUpload; translations: FileUpload[] }[]` | No       | —              |
| [`options`](#options) | Opciones de configuración de la carga.                                 | `UploadFilesOptions`                                   | No       | —              |

### `files` [#files]

**Tipo** `{ source: FileUpload; translations: FileUpload[] }[]` · **Obligatorio**

Cada entrada asocia una referencia a un archivo fuente con sus archivos traducidos:

```typescript
{
  source: FileUpload; // referencia a un archivo fuente existente (no se necesita contenido)
  translations: FileUpload[]; // archivos traducidos con contenido
}
```

La referencia `source` (un `FileUpload`) usa estos campos:

| Campo        | Descripción                                                                                                                        | Tipo         | Opcional |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------- | ------------ | -------- |
| `fileName`   | Nombre de archivo que coincide con el del archivo fuente cargado previamente.                                                      | `string`     | No       |
| `fileFormat` | Formato del archivo. Uno de `GTJSON`, `JSON`, `PO`, `POT`, `YAML`, `MDX`, `MD`, `TS`, `JS`, `HTML`, `TXT` o `TWILIO_CONTENT_JSON`. | `FileFormat` | No       |
| `fileId`     | ID del archivo fuente.                                                                                                             | `string`     | Sí       |
| `versionId`  | ID de versión del archivo fuente.                                                                                                  | `string`     | Sí       |

Cada traducción (un `FileUpload`) usa estos campos:

| Campo        | Descripción                                                                                                                        | Tipo         | Opcional |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------- | ------------ | -------- |
| `content`    | Contenido sin procesar del archivo traducido en forma de cadena.                                                                   | `string`     | No       |
| `fileName`   | Nombre de archivo de la traducción.                                                                                                | `string`     | No       |
| `fileFormat` | Formato del archivo. Uno de `GTJSON`, `JSON`, `PO`, `POT`, `YAML`, `MDX`, `MD`, `TS`, `JS`, `HTML`, `TXT` o `TWILIO_CONTENT_JSON`. | `FileFormat` | No       |
| `locale`     | Configuración regional de destino de la traducción.                                                                                | `string`     | No       |
| `fileId`     | ID del archivo.                                                                                                                    | `string`     | Sí       |
| `versionId`  | ID de versión.                                                                                                                     | `string`     | Sí       |

### `options` [#options]

**Tipo** `UploadFilesOptions` · **obligatorio**

Configuración para la subida:

| Campo           | Descripción                                          | Tipo     | Opcional |
| --------------- | ---------------------------------------------------- | -------- | -------- |
| `sourceLocale`  | La configuración regional de origen de los archivos. | `string` | No       |
| `modelProvider` | Preferencia del proveedor del modelo de IA.          | `string` | Sí       |
| `timeout`       | Tiempo de espera de la solicitud en milisegundos.    | `number` | Sí       |

*Nota: `branchId` no es una opción de subida. Es un campo por archivo dentro de cada objeto de archivo, no forma parte de `UploadFilesOptions`.*

## Devuelve [#returns]

**Tipo** `Promise<UploadFilesResponse>`

Se resuelve con un `UploadFilesResponse` que contiene las referencias de los archivos cargados y un resumen:

```typescript
type UploadFilesResponse = {
  uploadedFiles: FileReference[]; // referencias de archivos subidos
  count: number; // número de archivos subidos correctamente
  message: string; // mensaje de estado de la API
};
```

## Ejemplos [#examples]

```typescript
// Uso básico: subir traducciones para archivos fuente previamente subidos
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 fuente fue subido 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`);
```

```typescript
// Flujo completo: subir archivos fuente y luego sus traducciones
import { GT } from 'generaltranslation';
import fs from 'fs';

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

// Paso 1: Subir archivos fuente
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: Subir 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(`Uploaded ${translationResult.count} translations`);
```

```typescript
// Subir traducciones en lote para múltiples archivos fuente
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 [#notes]

* Los archivos fuente deben cargarse primero con [`uploadSourceFiles`](/docs/platform/core/reference/gt-class-methods/translation/upload-source-files).
* El objeto `source` de cada entrada hace referencia a un archivo fuente existente; no hace falta incluir contenido ahí.
* Cada traducción de la lista `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 de archivo incluyen `branchId` para el control de versiones con compatibilidad con ramas.